doc

alltypes

interface AbsentThrowableMessageProviderFactory

abstract fun translatableBased(translatable: Translatable): ThrowableThrown.AbsentThrowableMessageProvider

object AbsentThrowableMessageProviderFactoryBuilder : AbsentThrowableMessageProviderFactory

inline fun translatableBased(translatable: Translatable): ThrowableThrown.AbsentThrowableMessageProvider

object absolute : Keyword
object aDirectory : Keyword
class All<out T> : VarArgHelper<T>

val expected: T
val otherExpected: Array<out T>

class All<out T> : VarArgHelper<T>

All(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>

interface AnyAssertions

abstract fun <T> because(container: AssertionContainer<T>, reason: String, assertionCreator: Expect<T>.() -> Unit): Assertion
abstract fun <T, TSub : Any> isA(container: AssertionContainer<T>, subType: KClass<TSub>): SubjectChangerBuilder.ExecutionStep<T, TSub>
abstract fun <T> isNotIn(container: AssertionContainer<T>, expected: Iterable<T>): Assertion
abstract fun <T> isNotSameAs(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> isSameAs(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> notToBe(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : Any> notToBeNullButOfType(container: AssertionContainer<T?>, subType: KClass<T>): SubjectChangerBuilder.ExecutionStep<T?, T>
abstract fun <T> toBe(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> toBeNull(container: AssertionContainer<T>): Assertion
abstract fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, type: KClass<T>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
abstract fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion

interface AnyAssertions

abstract fun <T, TSub : Any> isA(expect: Expect<T>, subType: KClass<TSub>): ChangedSubjectPostStep<T, TSub>
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
abstract fun <T : Any> isNotNullBut(plant: AssertionPlantNullable<T?>, type: KClass<T>, expected: T): Assertion
abstract fun <T> isNotSame(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T : Any> isNullable(plant: AssertionPlantNullable<T?>, type: KClass<T>, expectedOrNull: T?): Assertion
abstract fun <T : Any> isNullIfNullGivenElse(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreatorOrNull: (AssertionPlant<T>.() -> Unit)?): Assertion
abstract fun <T> isSame(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T> notToBe(subjectProvider: SubjectProvider<T>, expected: T): Assertion
open fun <T : Any> notToBeNull(expect: Expect<T?>, subType: KClass<T>): ChangedSubjectPostStep<T?, T>
abstract fun <T> toBe(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T> toBeNull(subjectProvider: SubjectProvider<T>): Assertion
abstract fun <T : Any> toBeNullIfNullGivenElse(expect: Expect<T?>, type: KClass<T>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion

object AnyAssertionsBuilder : AnyAssertions

inline fun <T, TSub : Any> isA(expect: Expect<T>, subType: KClass<TSub>): ChangedSubjectPostStep<T, TSub>
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
inline fun <T : Any> isNotNullBut(plant: AssertionPlantNullable<T?>, type: KClass<T>, expected: T): Assertion
inline fun <T> isNotSame(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T : Any> isNullable(plant: AssertionPlantNullable<T?>, type: KClass<T>, expectedOrNull: T?): Assertion
inline fun <T : Any> isNullIfNullGivenElse(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreatorOrNull: (AssertionPlant<T>.() -> Unit)?): Assertion
inline fun <T> isSame(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T> notToBe(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T> toBe(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T> toBeNull(subjectProvider: SubjectProvider<T>): Assertion
inline fun <T : Any> toBeNullIfNullGivenElse(expect: Expect<T?>, type: KClass<T>, noinline assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
inline val typeTransformation: AnyTypeTransformationAssertionsBuilder

interface AnyTypeTransformation

interface TypeTransformationFailureHandler<in T : Any, out TSub : Any>

abstract fun createAndAddAssertionToPlant(warningTransformationFailed: Translatable, subjectPlant: BaseAssertionPlant<T?, *>, failingAssertion: Assertion, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

interface AnyTypeTransformation

interface Creator<S : Any, T : Any>

abstract fun create(parameterObject: AnyTypeTransformation.ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: AnyTypeTransformation.FailureHandler<S, T>): Unit

interface FailureHandler<in S : Any, out T : Any>

abstract fun createAndAddAssertionToPlant(parameterObject: AnyTypeTransformation.ParameterObject<S, T>): Unit
abstract fun createFailingAssertion(description: Translatable, representation: Any): Assertion

data class ParameterObject<out S : Any, in T : Any>

ParameterObject(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<S?, *>, assertionCreator: AssertionPlant<T>.() -> Unit, warningTransformationFailed: Translatable)
val assertionCreator: AssertionPlant<T>.() -> Unit
val description: Translatable
val representation: Any
val subjectPlant: BaseAssertionPlant<S?, *>
val warningTransformationFailed: Translatable

interface AnyTypeTransformationAssertions

abstract fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: AnyTypeTransformation.FailureHandler<T, TSub>): Unit
abstract fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Unit
abstract fun <S : Any, T : Any> transform(parameterObject: AnyTypeTransformation.ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: AnyTypeTransformation.FailureHandler<S, T>): Unit

object AnyTypeTransformationAssertionsBuilder : AnyTypeTransformationAssertions

inline fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: AnyTypeTransformation.FailureHandler<T, TSub>): Unit
inline val failureHandlers: AnyTypeTransformationFailureHandlerFactoryBuilder
inline fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Unit
inline fun <S : Any, T : Any> transform(parameterObject: AnyTypeTransformation.ParameterObject<S, T>, noinline canBeTransformed: (S) -> Boolean, noinline transform: (S) -> T, failureHandler: AnyTypeTransformation.FailureHandler<S, T>): Unit

object AnyTypeTransformationFailureHandlerFactoryBuilder : FailureHandlerFactory

inline fun <S : Any, T : Any> newExplanatory(): AnyTypeTransformation.FailureHandler<S, T>
inline fun <S : Any, T : Any> newExplanatoryWithHint(noinline showHint: () -> Boolean, noinline failureHintFactory: () -> Assertion): AnyTypeTransformation.FailureHandler<S, T>

object aRegularFile : Keyword
class ArgumentMapperBuilder<out T>

ArgumentMapperBuilder(first: T, others: Array<out T>)
val first: T
val others: Array<out T>
inline fun <reified R> to(mapper: (T) -> R): Pair<R, Array<out R>>
inline fun <reified R> toExpect(crossinline assertionCreator: Expect<R>.(T) -> Unit): Pair<Expect<R>.() -> Unit, Array<Expect<R>.() -> Unit>>

class ArgumentMapperBuilder<out T>

ArgumentMapperBuilder(first: T, others: Array<out T>)
val first: T
val others: Array<out T>
inline fun <reified R> to(mapper: (T) -> R): Pair<R, Array<out R>>
inline fun <reified R : Any> toAssert(crossinline assertionCreator: Assert<R>.(T) -> Unit): Pair<Assert<R>.() -> Unit, Array<Assert<R>.() -> Unit>>
inline fun <reified R> toAssertionPlantNullable(crossinline assertionCreator: AssertionPlantNullable<R>.(T) -> Unit): Pair<AssertionPlantNullable<R>.() -> Unit, Array<AssertionPlantNullable<R>.() -> Unit>>
inline fun <reified R> toExpect(crossinline assertionCreator: Expect<R>.(T) -> Unit): Pair<Expect<R>.() -> Unit, Array<Expect<R>.() -> Unit>>

abstract class ArgumentsSupportingTranslator : Translator

ArgumentsSupportingTranslator(primaryLocale: Locale, fallbackLocales: List<Locale>)
protected val fallbackLocales: List<Locale>
protected val primaryLocale: Locale
fun translate(translatable: Translatable): String
protected abstract fun translateWithoutArgs(translatable: Translatable): String

class ArgumentToNullOrMapperBuilder<T : Any>

ArgumentToNullOrMapperBuilder(argumentMapperBuilder: ArgumentMapperBuilder<T?>)
val argumentMapperBuilder: ArgumentMapperBuilder<T?>
inline fun <R : Any> toExpect(crossinline assertionCreator: Expect<R>.(T) -> Unit): Pair<(Expect<R>.() -> Unit)?, Array<(Expect<R>.() -> Unit)?>>

class ArgumentToNullOrMapperBuilder<T : Any>

ArgumentToNullOrMapperBuilder(argumentMapperBuilder: ArgumentMapperBuilder<T?>)
val argumentMapperBuilder: ArgumentMapperBuilder<T?>
inline fun <R : Any> toAssert(crossinline assertionCreator: Assert<R>.(T) -> Unit): Pair<(Assert<R>.() -> Unit)?, Array<(Assert<R>.() -> Unit)?>>
inline fun <R : Any> toExpect(crossinline assertionCreator: Expect<R>.(T) -> Unit): Pair<(Expect<R>.() -> Unit)?, Array<(Expect<R>.() -> Unit)?>>

typealias Assert<T> = AssertionPlant<T>
object AssertImpl : AssertImplCommon

inline val any: AnyAssertionsBuilder
inline val builder: AssertionBuilder
inline val charSequence: CharSequenceAssertionsBuilder
inline val collection: CollectionAssertionsBuilder
inline val collector: AssertionCollectorBuilder
inline val comparable: ComparableAssertionsBuilder
inline val coreFactory: CoreFactory
inline val feature: FeatureAssertionsBuilder
inline val floatingPoint: FloatingPointAssertionsBuilder
inline val iterable: IterableAssertionsBuilder
inline val list: ListAssertionsBuilder
inline val map: MapAssertionsBuilder
inline val pair: PairAssertionsBuilder
inline val throwable: ThrowableAssertionsBuilder

interface AssertImplCommon

abstract val any: AnyAssertionsBuilder
abstract val builder: AssertionBuilder
open fun <T, R : Any> changeSubject(originalPlant: BaseAssertionPlant<T, *>, subjectProvider: () -> R): AssertionPlant<R>
open fun <T, R : Any> changeSubject(originalAssertionCreator: Expect<T>, transformation: (T) -> R): Expect<R>
open fun <T, R> changeToNullableSubject(originalPlant: BaseAssertionPlant<T, *>, subjectProvider: () -> R): AssertionPlantNullable<R>
open fun <T, R : Any> changeToNullableSubject(originalAssertionCreator: Expect<T>, transformation: (T) -> R): Expect<R>
abstract val charSequence: CharSequenceAssertionsBuilder
abstract val collection: CollectionAssertionsBuilder
abstract val collector: AssertionCollectorBuilder
abstract val comparable: ComparableAssertionsBuilder
abstract val coreFactory: CoreFactory
abstract val feature: FeatureAssertionsBuilder
abstract val floatingPoint: FloatingPointAssertionsBuilder
abstract val iterable: IterableAssertionsBuilder
abstract val list: ListAssertionsBuilder
abstract val map: MapAssertionsBuilder
abstract val pair: PairAssertionsBuilder
abstract val throwable: ThrowableAssertionsBuilder

interface Assertion

abstract fun holds(): Boolean

interface AssertionBuilder

open fun createDescriptive(description: String, representation: Any?, test: () -> Boolean): DescriptiveAssertion
open fun createDescriptive(description: Translatable, representation: Any?, test: () -> Boolean): DescriptiveAssertion
open fun <T> createDescriptive(subjectProvider: SubjectProvider<T>, description: String, representation: Any?, test: (T) -> Boolean): DescriptiveAssertion
open fun <T> createDescriptive(subjectProvider: SubjectProvider<T>, description: Translatable, representation: Any?, test: (T) -> Boolean): DescriptiveAssertion
abstract fun <T : AssertionGroupType> customType(groupType: T): DefaultAssertionGroupBuilderOptions<T>
abstract val descriptive: Descriptive.HoldsOption
abstract val explanatory: Explanatory.ExplanationOption
abstract val explanatoryGroup: ExplanatoryAssertionGroupTypeOption
abstract val feature: DefaultAssertionGroupBuilderOptions<FeatureAssertionGroupType>
abstract val list: DefaultAssertionGroupBuilderOptions<ListAssertionGroupType>
abstract val representationOnly: RepresentationOnly.HoldsStep
abstract val summary: AssertionGroupDescriptionAndEmptyRepresentationOption<SummaryAssertionGroupType, AssertionsOption<SummaryAssertionGroupType, BasicAssertionGroupFinalStep>>

interface AssertionBuilderFinalStep<T : Assertion>

abstract fun build(): T

interface AssertionChecker

abstract fun check(assertionVerb: Translatable, representation: Any?, assertions: List<Assertion>): Unit
open fun check(assertionVerb: Translatable, representationProvider: () -> Any, assertions: List<Assertion>): Unit

interface AssertionCollector

open fun <T> collect(expect: Expect<T>, assertionCreator: Expect<T>.() -> Unit): Assertion
abstract fun <T> collect(maybeSubject: Option<T>, assertionCreator: Expect<T>.() -> Unit): Assertion
open fun <T : Any> collect(plant: AssertionPlant<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
open fun <T : Any> collect(subjectProvider: () -> T, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(subjectProvider: () -> T, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): AssertionGroup
abstract fun <T> collectForComposition(maybeSubject: Option<T>, assertionCreator: Expect<T>.() -> Unit): List<Assertion>
open fun <T> collectNullable(plant: AssertionPlantNullable<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullable(subjectProvider: () -> T, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullableOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, plant: AssertionPlantNullable<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullableOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T : Any> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, plant: AssertionPlant<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
open fun <T : Any> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): AssertionGroup

object AssertionCollectorBuilder : AssertionCollector

inline fun <T> collect(maybeSubject: Option<T>, noinline assertionCreator: Expect<T>.() -> Unit): Assertion
inline fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(noinline subjectProvider: () -> T, noinline collectingPlantFactory: (() -> T) -> C, noinline assertionCreator: C.() -> Unit): AssertionGroup
inline fun <T> collectForComposition(maybeSubject: Option<T>, noinline assertionCreator: Expect<T>.() -> Unit): List<Assertion>
inline fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, noinline subjectProvider: () -> T, noinline collectingPlantFactory: (() -> T) -> C, noinline assertionCreator: C.() -> Unit): AssertionGroup
inline val forExplanation: ExplainingAssertionCollectorOption

interface AssertionCollectorForExplanation

open fun <T : Any> collect(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, assertionCreator: (CollectingAssertionPlant<T>.() -> Unit)?): List<Assertion>
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, collectingPlantFactory: (() -> T) -> C, assertionCreator: (C.() -> Unit)?): List<Assertion>
open fun <T> collectNullable(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, assertionCreator: (CollectingAssertionPlantNullable<T>.() -> Unit)?): List<Assertion>

interface AssertionComposer

abstract fun createDescriptiveWithFailureHint(description: Translatable, representation: Any, test: () -> Boolean, showHint: () -> Boolean, failureHintFactory: () -> Assertion): Assertion

interface AssertionContainer<T> : SubjectProvider<T>

abstract fun <I : Any> getImpl(kClass: KClass<I>, defaultFactory: () -> I): I
abstract val maybeSubject: Option<T>

interface AssertionFormatter

val CALL_FORMAT_GROUP: String
abstract fun canFormat(assertion: Assertion): Boolean
open fun format(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
abstract fun formatGroup(assertionGroup: AssertionGroup, parameterObject: AssertionFormatterParameterObject, formatAssertions: (AssertionFormatterParameterObject, (Assertion) -> Unit) -> Unit): Unit
abstract fun formatNonGroup(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
fun throwNotIntendedForAssertionGroups(): Unit

data class AssertionFormatterChosenOptions

AssertionFormatterChosenOptions(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator)
val assertionFormatterFacade: AssertionFormatterFacade
val objectFormatter: ObjectFormatter
val translator: Translator

interface AssertionFormatterController

abstract fun format(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
open fun isExplanatoryAssertionGroup(assertion: Assertion): Boolean
fun noSuitableAssertionFormatterFound(assertion: Assertion): Nothing
abstract fun register(assertionFormatter: AssertionFormatter): Unit

interface AssertionFormatterControllerOption

fun create(objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatterControllerOption
abstract val objectFormatter: ObjectFormatter
abstract val translator: Translator
abstract fun withAssertionFormatterController(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacadeOption
abstract fun withDefaultAssertionFormatterController(): AssertionFormatterFacadeOption

interface AssertionFormatterFacade

abstract fun format(assertion: Assertion, sb: StringBuilder, assertionFilter: (Assertion) -> Boolean): Unit
abstract fun register(assertionFormatterFactory: (AssertionFormatterController) -> AssertionFormatter): Unit

interface AssertionFormatterFacadeOption

abstract val assertionFormatterController: AssertionFormatterController
fun create(assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatterFacadeOption
abstract val objectFormatter: ObjectFormatter
abstract val translator: Translator
abstract fun withAssertionFormatterFacade(factory: (AssertionFormatterController) -> AssertionFormatterFacade): AssertionPairFormatterOption
abstract fun withDefaultAssertionFormatterFacade(): AssertionPairFormatterOption

class AssertionFormatterParameterObject

fun appendLnAndIndent(): Unit
fun appendLnIndentAndPrefix(): Unit
val assertionFilter: (Assertion) -> Boolean
fun createChildWithNewPrefix(newPrefix: String): AssertionFormatterParameterObject
fun createChildWithNewPrefixAndAdditionalIndent(newPrefix: String, additionalIndent: Int): AssertionFormatterParameterObject
fun createForDoNotFilterAssertionGroup(): AssertionFormatterParameterObject
fun createForExplanatoryFilterAssertionGroup(newPrefix: String = prefix): AssertionFormatterParameterObject
fun indent(numberOfSpaces: Int): Unit
fun isNotInDoNotFilterGroup(): Boolean
fun isNotInExplanatoryFilterGroup(): Boolean
fun new(sb: StringBuilder, assertionFilter: (Assertion) -> Boolean): AssertionFormatterParameterObject
val prefix: String
val sb: StringBuilder

interface AssertionGroup : Assertion

abstract val assertions: List<Assertion>
object Builder

class BasicAssertionGroupBuilder

BasicAssertionGroupBuilder(groupType: AssertionGroupType)
fun create(name: Translatable, subject: Any, assertion: Assertion): AssertionGroup
fun create(name: Translatable, subject: Any, assertions: List<Assertion>): AssertionGroup

class EmptyNameAndSubjectAssertionGroupBuilder

EmptyNameAndSubjectAssertionGroupBuilder(groupType: AssertionGroupType)
fun create(assertion: Assertion): AssertionGroup
fun create(assertions: List<Assertion>): AssertionGroup

val explanatory: AssertionGroup.Builder.ExplanatoryAssertionGroupOption
class ExplanatoryAssertionGroupBuilder

ExplanatoryAssertionGroupBuilder(groupType: ExplanatoryAssertionGroupType)
fun create(assertion: Assertion): ExplanatoryAssertionGroup
fun create(assertions: List<Assertion>): ExplanatoryAssertionGroup

class ExplanatoryAssertionGroupOption

ExplanatoryAssertionGroupOption()
val withDefault: AssertionGroup.Builder.ExplanatoryAssertionGroupBuilder
fun withType(groupType: ExplanatoryAssertionGroupType): AssertionGroup.Builder.ExplanatoryAssertionGroupBuilder
val withWarning: AssertionGroup.Builder.ExplanatoryAssertionGroupBuilder

val feature: AssertionGroup.Builder.BasicAssertionGroupBuilder
val invisible: AssertionGroup.Builder.EmptyNameAndSubjectAssertionGroupBuilder
val list: AssertionGroup.Builder.BasicAssertionGroupBuilder
val root: AssertionGroup.Builder.BasicAssertionGroupBuilder
val summary: AssertionGroup.Builder.BasicAssertionGroupBuilder
fun withType(groupType: AssertionGroupType): AssertionGroup.Builder.BasicAssertionGroupBuilder

abstract val description: Translatable
open fun holds(): Boolean
open val name: Translatable
abstract val representation: Any
open val subject: Any
abstract val type: AssertionGroupType

interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType, R> create(type: T, factory: (T, Translatable, Any) -> R): AssertionGroupDescriptionAndEmptyRepresentationOption<T, R>
abstract val groupType: T
open fun withDescription(description: String): R
abstract fun withDescription(description: Translatable): R

interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType, R> create(type: T, factory: (T, Translatable, Any) -> R): AssertionGroupDescriptionAndRepresentationOption<T, R>
abstract val groupType: T
open fun withDescriptionAndEmptyRepresentation(description: String): R
open fun withDescriptionAndEmptyRepresentation(description: Translatable): R
open fun withDescriptionAndRepresentation(description: String, representationProvider: () -> Any?): R
open fun withDescriptionAndRepresentation(description: Translatable, representationProvider: () -> Any?): R
open fun withDescriptionAndRepresentation(description: String, representation: Any?): R
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): R

interface AssertionGroupType : BulletPointIdentifier
interface AssertionHolder

abstract fun addAssertion(assertion: Assertion): AssertionHolder

interface AssertionPairFormatter

abstract fun format(parameterObject: AssertionFormatterParameterObject, translatable: Translatable, representation: Any): Unit
abstract fun formatGroupHeader(parameterObject: AssertionFormatterParameterObject, assertionGroup: AssertionGroup, newParameterObject: AssertionFormatterParameterObject): Unit

interface AssertionPairFormatterOption

fun create(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatterOption
fun create(options: AssertionFormatterChosenOptions): AssertionPairFormatterOption
abstract val options: AssertionFormatterChosenOptions
abstract fun withTextAssertionPairFormatter(factory: (ObjectFormatter, Translator) -> AssertionPairFormatter): TextAssertionFormatterOption
open fun withTextNextLineAssertionPairFormatter(): TextAssertionFormatterOption
open fun withTextSameLineAssertionPairFormatter(): TextAssertionFormatterOption

interface AssertionPlant<out T : Any> : BaseAssertionPlant<T, AssertionPlant<T>>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun createAndAddAssertion(description: Translatable, expected: Any, test: () -> Boolean): AssertionPlant<T>

interface AssertionPlantNullable<out T> : BaseAssertionPlant<T, AssertionPlantNullable<T>>
interface AssertionPlantWithCommonFields<out T>

abstract val commonFields: AssertionPlantWithCommonFields.CommonFields<T>
class CommonFields<out T>

CommonFields(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any)
CommonFields(assertionVerb: Translatable, subjectProvider: () -> T, representationProvider: () -> Any?, assertionChecker: AssertionChecker, nullRepresentation: Any)
val assertionChecker: AssertionChecker
val assertionVerb: Translatable
fun check(assertions: List<Assertion>): Unit
val subjectProvider: () -> T

interface AssertionsOption<out T : AssertionGroupType, out R>

fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
fun <T : AssertionGroupType> factoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>

enum class AssertionVerb : StringBasedTranslatable

ASSERT
EXPECT_THROWN
val value: String

enum class AssertionVerb : StringBasedTranslatable

ASSERT
ASSERT_THAT
EXPECT
val value: String

enum class AssertionVerb : StringBasedTranslatable

ASSERT
ASSERT_THAT
ASSERT_THAT_THROWN
ASSERT_THROWN
EXPECT
EXPECT_THROWN
val value: String

object AssertionVerbFactory : AssertionVerbFactory

fun checkException(act: () -> Unit): ThrowableThrown.Builder
fun <T : Any> checkImmediately(subject: T): ReportingAssertionPlant<T>
fun <T : Any> checkLazily(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T> checkNullable(subject: T): ReportingAssertionPlantNullable<T>

@DslMarker annotation class AssertMarker

AssertMarker()

interface AtLeastChecker : WithTimesChecker

abstract val atLeastCall: (Int) -> String
abstract val nameContainsNotFun: String

interface AtLeastChecker : AtLeastChecker, CharSequenceContains.Checker
interface AtLeastChecker : AtLeastChecker, IterableLikeContains.Checker
interface AtLeastChecker : AtLeastChecker, MapLikeContains.Checker
interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtLeastCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

AtLeastCheckerOptionBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class AtLeastCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

AtLeastCheckerOptionBase(times: Int, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface AtLeastCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
interface AtLeastCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
interface AtMostChecker : WithTimesChecker

abstract val atMostCall: (Int) -> String
abstract val nameContainsNotFun: String

interface AtMostChecker : AtMostChecker, CharSequenceContains.Checker
interface AtMostChecker : AtMostChecker, IterableLikeContains.Checker
interface AtMostChecker : AtMostChecker, MapLikeContains.Checker
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtMostCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

AtMostCheckerOptionBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class AtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

AtMostCheckerOptionBase(times: Int, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

open class AtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

open class AtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface AtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
interface AtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
expect class AtriumError : AssertionError

fun create(message: String, atriumErrorAdjuster: AtriumErrorAdjuster): AtriumError
fun getLocalizedMessage(): String?
val message: String?
fun toString(): String

expect interface AtriumErrorAdjuster : AtriumErrorAdjusterCommon

abstract fun adjustStackTrace(stackTrace: Sequence<StackTraceElement>): Sequence<StackTraceElement>

interface AtriumErrorAdjusterCommon

abstract fun adjust(throwable: Throwable): Unit
abstract fun adjustOtherThanStacks(throwable: Throwable): Unit

interface AtriumErrorAdjusterCommonOption<R : Any>

abstract fun withAtriumErrorAdjuster(adjuster: AtriumErrorAdjuster): R
abstract fun withRemoveAtriumFromAtriumErrorAdjuster(): R
abstract fun withRemoveRunnerAtriumErrorAdjuster(): R

interface AtriumErrorAdjusterOption : AtriumErrorAdjusterCommonOption<ReporterOption>

abstract val assertionFormatterFacade: AssertionFormatterFacade
fun create(assertionFormatterFacade: AssertionFormatterFacade): AtriumErrorAdjusterOption
abstract fun withCustomReporter(factory: (AssertionFormatterFacade) -> Reporter): ReporterBuilderFinalStep
open fun withDefaultAtriumErrorAdjusters(): ReporterOption
abstract fun withMultipleAdjusters(configure: MultipleAdjustersOption.() -> Unit): ReporterOption
abstract fun withNoOpAtriumErrorAdjuster(): ReporterOption
abstract fun withOnlyFailureReporter(): ReporterBuilderFinalStep

interface BaseAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : SubjectProvider<T>

abstract fun addAssertion(assertion: Assertion): A
open val maybeSubject: Option<T>
abstract val subjectProvider: () -> T

interface BaseCollectingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>, out C : BaseCollectingAssertionPlant<T, A, C>> : BaseAssertionPlant<T, A>

abstract fun getAssertions(): List<Assertion>
abstract val subject: T

interface BaseReportingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : BaseAssertionPlant<T, A>, AssertionPlantWithCommonFields<T>
abstract class BaseTransformationExecutionStep<T, R, E : Expect<R>> : TransformationExecutionStep<T, R, E>

BaseTransformationExecutionStep(container: AssertionContainer<T>, action: AssertionContainer<T>.() -> E, actionAndApply: AssertionContainer<T>.(Expect<R>.() -> Unit) -> Expect<R>)
protected val action: AssertionContainer<T>.() -> E
protected val actionAndApply: AssertionContainer<T>.(Expect<R>.() -> Unit) -> Expect<R>
fun collect(assertionCreator: Expect<R>.() -> Unit): Assertion
fun collectAndAppend(assertionCreator: Expect<R>.() -> Unit): Expect<T>
protected val container: AssertionContainer<T>
fun transform(): E
fun transformAndAppend(assertionCreator: Expect<R>.() -> Unit): Expect<R>

data class BasicAssertionGroup : AssertionGroup

BasicAssertionGroup(type: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>)
val assertions: List<Assertion>
val description: Translatable
val representation: Any
val type: AssertionGroupType

interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>

abstract val assertions: List<Assertion>
fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>): BasicAssertionGroupFinalStep
abstract val description: Translatable
abstract val groupType: AssertionGroupType
abstract val representation: Any

class BasicDescriptiveAssertion : DescriptiveAssertion

BasicDescriptiveAssertion(description: Translatable, representation: Any, holds: Boolean)
BasicDescriptiveAssertion(description: Translatable, representation: Any, test: () -> Boolean)
val description: Translatable
fun holds(): Boolean
val representation: Any

class BasicExplanatoryAssertion : ExplanatoryAssertion

BasicExplanatoryAssertion(explanation: Any?)
val explanation: Any?
fun toString(): String

interface BigDecimalAssertions

abstract fun <T : BigDecimal> isEqualIncludingScale(container: AssertionContainer<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
abstract fun <T : BigDecimal> isNotEqualIncludingScale(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNotNumericallyEqualTo(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNumericallyEqualTo(container: AssertionContainer<T>, expected: T): Assertion

interface BigDecimalAssertions

abstract fun <T : BigDecimal> isEqualIncludingScale(subjectProvider: SubjectProvider<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
abstract fun <T : BigDecimal> isNotEqualIncludingScale(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNotNumericallyEqualTo(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNumericallyEqualTo(subjectProvider: SubjectProvider<T>, expected: T): Assertion

object BigDecimalAssertionsBuilder : BigDecimalAssertions

inline fun <T : BigDecimal> isEqualIncludingScale(subjectProvider: SubjectProvider<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
inline fun <T : BigDecimal> isNotEqualIncludingScale(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T : BigDecimal> isNotNumericallyEqualTo(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T : BigDecimal> isNumericallyEqualTo(subjectProvider: SubjectProvider<T>, expected: T): Assertion

object blank : Keyword
object Blank : Keyword
interface BulletPointIdentifier
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ButAtMostCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class ButAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<E, T, S>, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<E, T, S>, containsBuilder: IterableContains.Builder<E, T, S>)

open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<E, T, S>, containsBuilder: IterableContains.Builder<E, T, S>)

interface ButAtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
interface ButAtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
object case : Keyword
object case
object case : Keyword
class ChangedSubjectPostStep<T, R> : PostFinalStep<T, R, Expect<R>>

ChangedSubjectPostStep(expect: Expect<T>, transform: Expect<T>.() -> Expect<R>, transformAndApply: Expect<T>.(Expect<R>.() -> Unit) -> Expect<R>)

interface CharSequenceAssertions

abstract fun <T : CharSequence> containsBuilder(container: AssertionContainer<T>): CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
abstract fun <T : CharSequence> containsNotBuilder(container: AssertionContainer<T>): NotCheckerStep<T, NotSearchBehaviour>
abstract fun <T : CharSequence> endsNotWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> endsWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> isEmpty(container: AssertionContainer<T>): Assertion
abstract fun <T : CharSequence> isNotBlank(container: AssertionContainer<T>): Assertion
abstract fun <T : CharSequence> isNotEmpty(container: AssertionContainer<T>): Assertion
abstract fun <T : CharSequence> matches(container: AssertionContainer<T>, expected: Regex): Assertion
abstract fun <T : CharSequence> mismatches(container: AssertionContainer<T>, expected: Regex): Assertion
abstract fun <T : CharSequence> startsNotWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> startsWith(container: AssertionContainer<T>, expected: CharSequence): Assertion

interface CharSequenceAssertions

abstract fun <T : CharSequence> containsBuilder(subjectProvider: SubjectProvider<T>): CharSequenceContains.Builder<T, NoOpSearchBehaviour>
abstract fun <T : CharSequence> containsNotBuilder(subjectProvider: SubjectProvider<T>): CharSequenceContains.Builder<T, NotSearchBehaviour>
abstract fun endsNotWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
abstract fun endsWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
abstract fun isEmpty(subjectProvider: SubjectProvider<CharSequence>): Assertion
abstract fun isNotBlank(subjectProvider: SubjectProvider<CharSequence>): Assertion
abstract fun isNotEmpty(subjectProvider: SubjectProvider<CharSequence>): Assertion
abstract fun <T : CharSequence> matches(expect: Expect<T>, expected: Regex): Assertion
abstract fun <T : CharSequence> mismatches(expect: Expect<T>, expected: Regex): Assertion
abstract fun startsNotWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
abstract fun startsWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion

object CharSequenceAssertionsBuilder : CharSequenceAssertions

inline val contains: CharSequenceContainsAssertionsBuilder
inline fun <T : CharSequence> containsBuilder(subjectProvider: SubjectProvider<T>): CharSequenceContains.Builder<T, NoOpSearchBehaviour>
inline fun <T : CharSequence> containsNotBuilder(subjectProvider: SubjectProvider<T>): CharSequenceContains.Builder<T, NotSearchBehaviour>
inline fun endsNotWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
inline fun endsWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
inline fun isEmpty(subjectProvider: SubjectProvider<CharSequence>): Assertion
inline fun isNotBlank(subjectProvider: SubjectProvider<CharSequence>): Assertion
inline fun isNotEmpty(subjectProvider: SubjectProvider<CharSequence>): Assertion
inline fun <T : CharSequence> matches(expect: Expect<T>, expected: Regex): Assertion
inline fun <T : CharSequence> mismatches(expect: Expect<T>, expected: Regex): Assertion
inline fun startsNotWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
inline fun startsWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion

interface CharSequenceContains

interface Checker : Contains.Checker
interface CheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerStep<T, S, CharSequenceContains.Checker, CharSequenceContains.EntryPointStep<T, S>>
interface CheckerStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>, CharSequenceContains.CheckerStepLogic<T, S>
interface CheckerStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerStepLogic<T, S, CharSequenceContains.Checker, CharSequenceContains.EntryPointStepLogic<T, S>>
interface Creator<T : CharSequence, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.EntryPointStep<T, S>, CharSequenceContains.EntryPointStepLogic<T, S>
interface EntryPointStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>
interface SearchBehaviour : Contains.SearchBehaviour
interface Searcher<S : CharSequenceContains.SearchBehaviour, SC>

abstract fun search(searchIn: CharSequence, searchFor: SC): Int

interface CharSequenceContains

interface Builder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.Builder<T, S>
interface Checker : Contains.Checker
interface CheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerOption<T, S, CharSequenceContains.Checker, CharSequenceContains.Builder<T, S>>
interface Creator<in T : CharSequence, in SC> : Contains.Creator<T, SC>
interface SearchBehaviour : Contains.SearchBehaviour
interface Searcher<S : CharSequenceContains.SearchBehaviour, SC>

abstract fun search(searchIn: CharSequence, searchFor: SC): Int

interface CharSequenceContains

interface Checker : Contains.Checker, CharSequenceContains.Checker
interface Creator<in T : CharSequence, in SC> : Contains.Creator<T, SC>, CharSequenceContains.Creator<T, SC>
interface SearchBehaviour : Contains.SearchBehaviour, CharSequenceContains.SearchBehaviour
interface Searcher<S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.Searcher<S, Any>

class CharSequenceContainsAssertionCreator<T : CharSequence, in SC : Any, S : CharSequenceContains.SearchBehaviour> : ContainsObjectsAssertionCreator<T, String, SC, S, CharSequenceContains.Checker>, CharSequenceContains.Creator<T, SC>

CharSequenceContainsAssertionCreator(searchBehaviour: S, searcher: CharSequenceContains.Searcher<S, SC>, checkers: List<CharSequenceContains.Checker>, groupDescription: Translatable)
fun decorateAssertion(container: AssertionContainer<String>, featureAssertion: Assertion): List<Assertion>
protected val descriptionContains: Translatable
protected val descriptionNumberOfOccurrences: Translatable
protected fun getAssertionGroupType(): AssertionGroupType
protected val groupDescription: Translatable
protected fun makeSubjectMultipleTimesConsumable(container: AssertionContainer<T>): AssertionContainer<String>
protected fun search(multiConsumableContainer: AssertionContainer<String>, searchCriterion: SC): Int

class CharSequenceContainsAssertionCreator<T : CharSequence, S : CharSequenceContains.SearchBehaviour> : ContainsObjectsAssertionCreator<T, Any, S, CharSequenceContains.Checker>, CharSequenceContains.Creator<T, Any>

CharSequenceContainsAssertionCreator(searchBehaviour: S, searcher: CharSequenceContains.Searcher<S, Any>, checkers: List<CharSequenceContains.Checker>)
protected val descriptionContains: DescriptionCharSequenceAssertion
protected val descriptionNumberOfOccurrences: DescriptionCharSequenceAssertion
protected fun search(subjectProvider: SubjectProvider<T>, searchCriterion: Any): Int

interface CharSequenceContainsAssertions

abstract fun <T : CharSequence> regex(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, NoOpSearchBehaviour>, expected: List<Regex>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, NoOpSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, IgnoringCaseSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup

interface CharSequenceContainsAssertions

abstract fun <T : CharSequence> defaultTranslationOf(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> regex(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<Regex>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup

object CharSequenceContainsAssertionsBuilder : CharSequenceContainsAssertions

inline fun <T : CharSequence> defaultTranslationOf(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
inline fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
@JvmName("stringRegex") inline fun <T : CharSequence> regex(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): AssertionGroup
inline fun <T : CharSequence> regex(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<Regex>): AssertionGroup
inline fun <T : CharSequence> regexIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
inline val searchBehaviours: CharSequenceContainsSearchBehaviourFactoryBuilder
inline fun <T : CharSequence> values(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup
inline fun <T : CharSequence> valuesIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup

class CharSequenceContainsAtLeastChecker : CharSequenceContainsChecker

CharSequenceContainsAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

abstract class CharSequenceContainsAtLeastCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilderBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

class CharSequenceContainsAtMostChecker : CharSequenceContainsChecker

CharSequenceContainsAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

abstract class CharSequenceContainsAtMostCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilderBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

class CharSequenceContainsBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ContainsBuilder<T, S>, CharSequenceContains.Builder<T, S>

CharSequenceContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

abstract class CharSequenceContainsButAtMostCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilderBase<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class CharSequenceContainsChecker : ContainsChecker, CharSequenceContains.Checker

CharSequenceContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)

interface CharSequenceContainsCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ContainsCheckerBuilder<T, S, CharSequenceContains.Checker, CharSequenceContains.Builder<T, S>>, CharSequenceContains.CheckerOption<T, S>
class CharSequenceContainsExactlyChecker : CharSequenceContainsChecker

CharSequenceContainsExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

abstract class CharSequenceContainsExactlyCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilderBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

class CharSequenceContainsIgnoringCaseIndexSearcher : CharSequenceContains.Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>

CharSequenceContainsIgnoringCaseIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class CharSequenceContainsIgnoringCaseRegexSearcher : CharSequenceContains.Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>

CharSequenceContainsIgnoringCaseRegexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

open class CharSequenceContainsIgnoringCaseSearchBehaviour : CharSequenceContains.SearchBehaviour, IgnoringCaseSearchBehaviour

CharSequenceContainsIgnoringCaseSearchBehaviour(previousBehaviour: NoOpSearchBehaviour)
open fun decorateDescription(description: Translatable): Translatable

class CharSequenceContainsIndexSearcher : CharSequenceContains.Searcher<CharSequenceContainsNoOpSearchBehaviour>

CharSequenceContainsIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

open class CharSequenceContainsNoOpSearchBehaviour : CharSequenceContains.SearchBehaviour, NoOpSearchBehaviour

CharSequenceContainsNoOpSearchBehaviour()

class CharSequenceContainsNotChecker : CharSequenceContains.Checker

CharSequenceContainsNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: CharSequenceContains.Builder<T, S>)

abstract class CharSequenceContainsNotCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilderBase(containsBuilder: CharSequenceContains.Builder<T, S>)
open val checkers: List<CharSequenceContainsNotChecker>
open val containsBuilder: CharSequenceContains.Builder<T, S>

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

abstract class CharSequenceContainsNotOrAtMostCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilderBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

open class CharSequenceContainsNotSearchBehaviour : CharSequenceContainsNoOpSearchBehaviour, NotSearchBehaviour

CharSequenceContainsNotSearchBehaviour()
open fun decorateDescription(description: Translatable): DescriptionCharSequenceAssertion

class CharSequenceContainsRegexSearcher : CharSequenceContains.Searcher<CharSequenceContainsNoOpSearchBehaviour>

CharSequenceContainsRegexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int
fun search(searchIn: CharSequence, pattern: Pattern): Int

object CharSequenceContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory

inline fun <T : CharSequence> ignoringCase(containsBuilder: CharSequenceContains.Builder<T, NoOpSearchBehaviour>): CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>

object CharSequenceContainsSearchersKt

@JvmStatic fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> values(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>

object CharSequenceContainsSearchersKt

@JvmStatic fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>

object CharSequenceContainsSearchersKt

@JvmStatic fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> standardUebersetzungVon(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> wert(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> werte(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>

typealias CharSequenceOrNumberOrChar = Any
typealias CharSequenceOrNumberOrChar = Any
interface CheckerFactory

abstract fun newAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): CharSequenceContains.Checker
abstract fun newAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): CharSequenceContains.Checker
abstract fun newExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): CharSequenceContains.Checker
abstract fun newNotChecker(): CharSequenceContains.Checker

interface CheckerFactory

abstract fun newAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): IterableContains.Checker
abstract fun newAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): IterableContains.Checker
abstract fun newExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): IterableContains.Checker
abstract fun newNotChecker(): IterableContains.Checker

interface CheckingAssertionPlant<out T : Any> : AssertionPlant<T>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): CheckingAssertionPlant<T>
abstract fun allAssertionsHold(): Boolean

interface ChronoLocalDateAssertions

abstract fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: String): Assertion

interface ChronoLocalDateAssertions

abstract fun <T : ChronoLocalDate> isAfter(expect: Expect<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEquals(expect: Expect<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBefore(expect: Expect<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEquals(expect: Expect<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isEqual(expect: Expect<T>, expected: ChronoLocalDate): Assertion

object ChronoLocalDateAssertionsBuilder : ChronoLocalDateAssertions

inline fun <T : ChronoLocalDate> isAfter(expect: Expect<T>, expected: ChronoLocalDate): Assertion
inline fun <T : ChronoLocalDate> isAfterOrEquals(expect: Expect<T>, expected: ChronoLocalDate): Assertion
inline fun <T : ChronoLocalDate> isBefore(expect: Expect<T>, expected: ChronoLocalDate): Assertion
inline fun <T : ChronoLocalDate> isBeforeOrEquals(expect: Expect<T>, expected: ChronoLocalDate): Assertion
inline fun <T : ChronoLocalDate> isEqual(expect: Expect<T>, expected: ChronoLocalDate): Assertion

interface ChronoLocalDateTimeAssertions

abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion

interface ChronoLocalDateTimeAssertions

abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEquals(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEquals(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion

object ChronoLocalDateTimeAssertionsBuilder : ChronoLocalDateTimeAssertions

inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEquals(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEquals(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion

interface ChronoZonedDateTimeAssertions

abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion

interface ChronoZonedDateTimeAssertions

abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion

object ChronoZonedDateTimeAssertionsBuilder : ChronoZonedDateTimeAssertions

inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion

interface CollectingAssertionContainer<T> : Expect<T>

abstract fun addAssertion(assertion: Assertion): CollectingAssertionContainer<T>
abstract fun addAssertionsCreatedBy(assertionCreator: Expect<T>.() -> Unit): CollectingAssertionContainer<T>
abstract fun getAssertions(): List<Assertion>

interface CollectingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseCollectingAssertionPlant<T, AssertionPlant<T>, CollectingAssertionPlant<T>>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): CollectingAssertionPlant<T>

interface CollectingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseCollectingAssertionPlant<T, AssertionPlantNullable<T>, CollectingAssertionPlantNullable<T>>
interface CollectingExpect<T> : Expect<T>

abstract fun addAssertionsCreatedBy(assertionCreator: Expect<T>.() -> Unit): CollectingExpect<T>
abstract fun getAssertions(): List<Assertion>
operator fun <T> invoke(maybeSubject: Option<T>): CollectingExpect<T>

interface CollectionAssertions

abstract fun hasSize(plant: AssertionPlant<Collection<*>>, size: Int): Assertion
abstract fun isEmpty(subjectProvider: SubjectProvider<Collection<*>>): Assertion
abstract fun isNotEmpty(subjectProvider: SubjectProvider<Collection<*>>): Assertion
abstract fun <T : Collection<*>> size(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun size(plant: AssertionPlant<Collection<*>>, assertionCreator: Assert<Int>.() -> Unit): Assertion

object CollectionAssertionsBuilder : CollectionAssertions

inline fun hasSize(plant: AssertionPlant<Collection<*>>, size: Int): Assertion
inline fun isEmpty(subjectProvider: SubjectProvider<Collection<*>>): Assertion
inline fun isNotEmpty(subjectProvider: SubjectProvider<Collection<*>>): Assertion
inline fun <T : Collection<*>> size(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun size(plant: AssertionPlant<Collection<*>>, noinline assertionCreator: Assert<Int>.() -> Unit): Assertion

typealias CollectionLike = Any
interface CollectionLikeAssertions

abstract fun <T> isEmpty(container: AssertionContainer<T>, converter: (T) -> Collection<*>): Assertion
abstract fun <T> isNotEmpty(container: AssertionContainer<T>, converter: (T) -> Collection<*>): Assertion
abstract fun <T> size(container: AssertionContainer<T>, converter: (T) -> Collection<*>): FeatureExtractorBuilder.ExecutionStep<T, Int>

interface ComparableAssertions

abstract fun <T1 : Comparable<T2>, T2> isEqualComparingTo(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion

interface ComparableAssertions

abstract fun <T1 : Comparable<T2>, T2> isEqualComparingTo(expect: Expect<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterOrEquals(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThan(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessOrEquals(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThan(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion

object ComparableAssertionsBuilder : ComparableAssertions

inline fun <T1 : Comparable<T2>, T2> isEqualComparingTo(expect: Expect<T1>, expected: T2): Assertion
inline fun <T1 : Comparable<T2>, T2> isGreaterOrEquals(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
inline fun <T1 : Comparable<T2>, T2> isGreaterThan(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
inline fun <T1 : Comparable<T2>, T2> isLessOrEquals(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
inline fun <T1 : Comparable<T2>, T2> isLessThan(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion

object contain
object contain : Keyword
interface Contains

interface Checker

abstract fun createAssertion(foundNumberOfTimes: Int): Assertion

interface CheckerStep<T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.EntryPointStep<T, S>>
interface CheckerStepLogic<T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.EntryPointStepLogic<T, S>>

abstract val checkers: List<C>
abstract val entryPointStepLogic: B

interface Creator<T, in SC>

abstract fun createAssertionGroup(container: AssertionContainer<T>, searchCriteria: List<SC>): AssertionGroup

interface EntryPointStep<T : Any, out S : Contains.SearchBehaviour>
interface EntryPointStepLogic<T : Any, out S : Contains.SearchBehaviour>

abstract val container: AssertionContainer<T>
abstract val searchBehaviour: S

interface SearchBehaviour

abstract fun decorateDescription(description: Translatable): Translatable

interface Contains

interface Builder<out T : Any, out S : Contains.SearchBehaviour>

abstract val searchBehaviour: S
abstract val subjectProvider: SubjectProvider<T>

interface Checker

abstract fun createAssertion(foundNumberOfTimes: Int): Assertion

interface CheckerOption<out T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.Builder<T, S>>

abstract val checkers: List<C>
abstract val containsBuilder: B

interface Creator<in T : Any, in SC>

abstract fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriteria: List<SC>): AssertionGroup

interface SearchBehaviour

abstract fun decorateDescription(description: Translatable): Translatable

interface Contains

interface Checker : Contains.Checker
interface Creator<in T : Any, in SC> : Contains.Creator<T, SC>
interface SearchBehaviour : Contains.SearchBehaviour

abstract class ContainsAssertionCreator<T : Any, TT : Any, in SC, C : Contains.Checker> : Contains.Creator<T, SC>

ContainsAssertionCreator(searchBehaviour: Contains.SearchBehaviour, checkers: List<C>)
fun createAssertionGroup(container: AssertionContainer<T>, searchCriteria: List<SC>): AssertionGroup
protected abstract val descriptionContains: Translatable
protected abstract fun makeSubjectMultipleTimesConsumable(container: AssertionContainer<T>): AssertionContainer<TT>
protected abstract fun searchAndCreateAssertion(multiConsumableContainer: AssertionContainer<TT>, searchCriterion: SC, featureFactory: (numberOfOccurrences: Int, description: Translatable) -> AssertionGroup): AssertionGroup
protected val searchBehaviour: Contains.SearchBehaviour

abstract class ContainsAssertionCreator<T : Any, S, C : Contains.Checker> : Contains.Creator<T, S>

ContainsAssertionCreator(checkers: List<C>)
fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriteria: List<S>): AssertionGroup
fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriterion: S, otherSearchCriteria: Array<out S>): AssertionGroup
protected abstract fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected abstract fun searchAndCreateAssertion(subjectProvider: SubjectProvider<T>, searchCriterion: S, featureFactory: (numberOfOccurrences: Int, description: Translatable) -> AssertionGroup): AssertionGroup

abstract class ContainsBuilder<out T : Any, out S : Contains.SearchBehaviour> : Contains.Builder<T, S>

ContainsBuilder(subjectProvider: AssertionPlant<T>, searchBehaviour: S)
open val searchBehaviour: S
open val subjectProvider: AssertionPlant<T>

abstract class ContainsChecker : Contains.Checker

ContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)
protected fun createDescriptiveAssertion(description: Translatable, check: () -> Boolean): DescriptiveAssertion
val times: Int

abstract class ContainsChecker : Contains.Checker

ContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)
protected fun createBasicAssertion(description: Translatable, check: Boolean): DescriptiveAssertion
val times: Int

interface ContainsCheckerBuilder<out T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.Builder<T, S>> : Contains.CheckerOption<T, S, C, B>
abstract class ContainsObjectsAssertionCreator<T : Any, TT : Any, in SC, S : Contains.SearchBehaviour, C : Contains.Checker> : ContainsAssertionCreator<T, TT, SC, C>

ContainsObjectsAssertionCreator(searchBehaviour: S, checkers: List<C>)
abstract fun decorateAssertion(container: AssertionContainer<TT>, featureAssertion: Assertion): List<Assertion>
protected abstract val descriptionNumberOfOccurrences: Translatable
protected abstract fun getAssertionGroupType(): AssertionGroupType
protected abstract val groupDescription: Translatable
protected abstract fun search(multiConsumableContainer: AssertionContainer<TT>, searchCriterion: SC): Int
protected fun searchAndCreateAssertion(multiConsumableContainer: AssertionContainer<TT>, searchCriterion: SC, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

abstract class ContainsObjectsAssertionCreator<T : Any, S, B : Contains.SearchBehaviour, C : Contains.Checker> : ContainsAssertionCreator<T, S, C>

ContainsObjectsAssertionCreator(searchBehaviour: B, checkers: List<C>)
protected fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected abstract val descriptionContains: Translatable
protected abstract val descriptionNumberOfOccurrences: Translatable
protected abstract fun search(subjectProvider: SubjectProvider<T>, searchCriterion: S): Int
protected fun searchAndCreateAssertion(subjectProvider: SubjectProvider<T>, searchCriterion: S, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

expect interface CoreFactory : CoreFactoryCommon

abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, nullRepresentation: Any = Text.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker, nullRepresentation: Any = Text.NULL): ReportingAssertionPlantNullable<T>

interface CoreFactoryCommon

abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subjectProvider: () -> T): CheckingAssertionPlant<T>
abstract fun <T> newCollectingAssertionContainer(maybeSubject: Option<T>): CollectingAssertionContainer<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newCollectingPlantNullable(subjectProvider: () -> T): CollectingAssertionPlantNullable<T>
abstract fun newDelegatingAssertionChecker(originalAssertionHolder: AssertionHolder): AssertionChecker
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
open fun <T> newDelegatingReportingAssertionContainer(originalAssertionHolder: AssertionHolder, maybeSubject: Option<T>): Expect<T>
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun newFeatureAssertionChecker(originalAssertionHolder: AssertionHolder): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newMultiAtriumErrorAdjuster(firstAdjuster: AtriumErrorAdjuster, secondAdjuster: AtriumErrorAdjuster, otherAdjusters: List<AtriumErrorAdjuster>): AtriumErrorAdjuster
abstract fun newNoOpAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade, atriumErrorAdjuster: AtriumErrorAdjuster): Reporter
abstract fun newRemoveAtriumFromAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newRemoveRunnerAtriumErrorAdjuster(): AtriumErrorAdjuster
open fun <T> newReportingAssertionContainer(assertionVerb: Translatable, maybeSubject: Option<T>, assertionChecker: AssertionChecker): ReportingAssertionContainer<T>
abstract fun <T> newReportingAssertionContainer(assertionCheckerDecorator: ReportingAssertionContainer.AssertionCheckerDecorator<T>): ReportingAssertionContainer<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: AssertionPlantWithCommonFields.CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
abstract fun <T> newReportingPlantNullable(commonFields: AssertionPlantWithCommonFields.CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextNextLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit

class DefaultAnyAssertions : AnyAssertions

DefaultAnyAssertions()
fun <T> because(container: AssertionContainer<T>, reason: String, assertionCreator: Expect<T>.() -> Unit): Assertion
fun <T, TSub : Any> isA(container: AssertionContainer<T>, subType: KClass<TSub>): SubjectChangerBuilder.ExecutionStep<T, TSub>
fun <T> isNotIn(container: AssertionContainer<T>, expected: Iterable<T>): Assertion
fun <T> isNotSameAs(container: AssertionContainer<T>, expected: T): Assertion
fun <T> isSameAs(container: AssertionContainer<T>, expected: T): Assertion
fun <T> notToBe(container: AssertionContainer<T>, expected: T): Assertion
fun <T : Any> notToBeNullButOfType(container: AssertionContainer<T?>, subType: KClass<T>): SubjectChangerBuilder.ExecutionStep<T?, T>
fun <T> toBe(container: AssertionContainer<T>, expected: T): Assertion
fun <T> toBeNull(container: AssertionContainer<T>): Assertion
fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, type: KClass<T>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion

typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
class DefaultAtLeastChecker : AtLeastChecker, ContainsChecker

DefaultAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
val atLeastCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultAtLeastChecker : AtLeastChecker, ContainsChecker

DefaultAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
val atLeastCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultAtLeastChecker : AtLeastChecker, ContainsChecker

DefaultAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
val atLeastCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultAtMostChecker : AtMostChecker, ContainsChecker

DefaultAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
val atMostCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultAtMostChecker : AtMostChecker, ContainsChecker

DefaultAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
val atMostCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultAtMostChecker : AtMostChecker, ContainsChecker

DefaultAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
val atMostCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultBigDecimalAssertions : BigDecimalAssertions

DefaultBigDecimalAssertions()
fun <T : BigDecimal> isEqualIncludingScale(container: AssertionContainer<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
fun <T : BigDecimal> isNotEqualIncludingScale(container: AssertionContainer<T>, expected: T): Assertion
fun <T : BigDecimal> isNotNumericallyEqualTo(container: AssertionContainer<T>, expected: T): Assertion
fun <T : BigDecimal> isNumericallyEqualTo(container: AssertionContainer<T>, expected: T): Assertion

class DefaultCharSequenceAssertions : CharSequenceAssertions

DefaultCharSequenceAssertions()
fun <T : CharSequence> containsBuilder(container: AssertionContainer<T>): CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
fun <T : CharSequence> containsNotBuilder(container: AssertionContainer<T>): NotCheckerStep<T, NotSearchBehaviour>
fun <T : CharSequence> endsNotWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
fun <T : CharSequence> endsWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
fun <T : CharSequence> isEmpty(container: AssertionContainer<T>): Assertion
fun <T : CharSequence> isNotBlank(container: AssertionContainer<T>): Assertion
fun <T : CharSequence> isNotEmpty(container: AssertionContainer<T>): Assertion
fun <T : CharSequence> matches(container: AssertionContainer<T>, expected: Regex): Assertion
fun <T : CharSequence> mismatches(container: AssertionContainer<T>, expected: Regex): Assertion
fun <T : CharSequence> startsNotWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
fun <T : CharSequence> startsWith(container: AssertionContainer<T>, expected: CharSequence): Assertion

class DefaultCharSequenceContainsAssertions : CharSequenceContainsAssertions

DefaultCharSequenceContainsAssertions()
fun <T : CharSequence> regex(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, NoOpSearchBehaviour>, expected: List<Regex>): AssertionGroup
fun <T : CharSequence> regexIgnoringCase(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
fun <T : CharSequence> values(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, NoOpSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup
fun <T : CharSequence> valuesIgnoringCase(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, IgnoringCaseSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup

class DefaultChronoLocalDateAssertions : ChronoLocalDateAssertions

DefaultChronoLocalDateAssertions()
fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: String): Assertion

class DefaultChronoLocalDateTimeAssertions : ChronoLocalDateTimeAssertions

DefaultChronoLocalDateTimeAssertions()
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion

class DefaultChronoZonedDateTimeAssertions : ChronoZonedDateTimeAssertions

DefaultChronoZonedDateTimeAssertions()
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion

class DefaultCollectionLikeAssertions : CollectionLikeAssertions

DefaultCollectionLikeAssertions()
fun <T> isEmpty(container: AssertionContainer<T>, converter: (T) -> Collection<*>): Assertion
fun <T> isNotEmpty(container: AssertionContainer<T>, converter: (T) -> Collection<*>): Assertion
fun <T> size(container: AssertionContainer<T>, converter: (T) -> Collection<*>): FeatureExtractorBuilder.ExecutionStep<T, Int>

class DefaultComparableAssertions : ComparableAssertions

DefaultComparableAssertions()
fun <T1 : Comparable<T2>, T2> isEqualComparingTo(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isGreaterThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isLessThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion

class DefaultExactlyChecker : ExactlyChecker, ContainsChecker

DefaultExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion
val exactlyCall: (Int) -> String
val nameContainsNotFun: String

class DefaultExactlyChecker : ExactlyChecker, ContainsChecker

DefaultExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion
val exactlyCall: (Int) -> String
val nameContainsNotFun: String

class DefaultExactlyChecker : ExactlyChecker, ContainsChecker

DefaultExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion
val exactlyCall: (Int) -> String
val nameContainsNotFun: String

object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType
class DefaultFailureHandlerImpl<T, R> : SubjectChanger.FailureHandler<T, R>

DefaultFailureHandlerImpl()
fun createAssertion(container: AssertionContainer<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion

object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType
class DefaultFeatureAssertions : FeatureAssertions

DefaultFeatureAssertions()
fun <T, R> f0(container: AssertionContainer<T>, f: KFunction1<T, R>): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, R> f1(container: AssertionContainer<T>, f: KFunction2<T, A1, R>, a1: A1): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, R> f2(container: AssertionContainer<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, R> f3(container: AssertionContainer<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, A4, R> f4(container: AssertionContainer<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, A4, A5, R> f5(container: AssertionContainer<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, R> manualFeature(container: AssertionContainer<T>, description: Translatable, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, TProperty> property(container: AssertionContainer<T>, property: KProperty1<in T, TProperty>): FeatureExtractorBuilder.ExecutionStep<T, TProperty>

class DefaultFeatureExtractor : FeatureExtractor

DefaultFeatureExtractor()
fun <T, R> extract(container: AssertionContainer<T>, description: Translatable, representationForFailure: Any, featureExtraction: (T) -> Option<R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>

class DefaultFloatingPointAssertions : FloatingPointAssertions

DefaultFloatingPointAssertions()
fun toBeWithErrorTolerance(container: AssertionContainer<Float>, expected: Float, tolerance: Float): Assertion
fun toBeWithErrorTolerance(container: AssertionContainer<Double>, expected: Double, tolerance: Double): Assertion

class DefaultFloatingPointJvmAssertions : FloatingPointJvmAssertions

DefaultFloatingPointJvmAssertions()
fun <T : BigDecimal> toBeWithErrorTolerance(container: AssertionContainer<T>, expected: BigDecimal, tolerance: BigDecimal): Assertion

class DefaultFun0Assertions : Fun0Assertions

DefaultFun0Assertions()
fun <R, T : () -> R> notToThrow(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<*, R>
fun <TExpected : Throwable> toThrow(container: AssertionContainer<() -> Any?>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<*, TExpected>

object DefaultIndentAssertionGroupType : IndentAssertionGroupType
class DefaultIterableLikeAssertions : IterableLikeAssertions

DefaultIterableLikeAssertions()
fun <T, E> all(container: AssertionContainer<T>, converter: (T) -> Iterable<E?>, assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Assertion
fun <T, E> builderContainsInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>
fun <T, E> builderContainsNotInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): NotCheckerStep<E, T, NotSearchBehaviour>
fun <T, E> containsNoDuplicates(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E> hasNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E> hasNotNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E : Comparable<E>> max(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
fun <T, E : Comparable<E>> min(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>

class DefaultIterableLikeContainsAssertions : IterableLikeContainsAssertions

DefaultIterableLikeContainsAssertions()
fun <E : Any, T> entriesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
fun <E : Any, T> entriesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
fun <E : Any, T> entriesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>): Assertion
fun <E, T> valuesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
fun <E, T> valuesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
fun <E, T> valuesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

class DefaultIterableLikeContainsInAnyOrderAssertions : IterableLikeContainsInAnyOrderAssertions

DefaultIterableLikeContainsInAnyOrderAssertions()
fun <E : Any, T> entries(checkerStepLogic: IterableLikeContains.CheckerStepLogic<out E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
fun <E, T> values(checkerStepLogic: IterableLikeContains.CheckerStepLogic<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion

class DefaultIterableLikeToIterableTransformer : IterableLikeToIterableTransformer

DefaultIterableLikeToIterableTransformer()
fun supportedTypes(): List<String>
fun <T> unsafeTransform(iterableLike: IterableLike): Iterable<T>

class DefaultIteratorAssertions : IteratorAssertions

DefaultIteratorAssertions()
fun <E, T : Iterator<E>> hasNext(container: AssertionContainer<T>): Assertion
fun <E, T : Iterator<E>> hasNotNext(container: AssertionContainer<T>): Assertion

object DefaultListAssertionGroupType : ListAssertionGroupType
class DefaultListAssertions : ListAssertions

DefaultListAssertions()
fun <E, T : List<E>> get(container: AssertionContainer<T>, index: Int): FeatureExtractorBuilder.ExecutionStep<T, E>

class DefaultLocalDateAssertions : LocalDateAssertions

DefaultLocalDateAssertions()
fun day(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>
fun dayOfWeek(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, DayOfWeek>
fun month(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>
fun year(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>

class DefaultLocalDateTimeAssertions : LocalDateTimeAssertions

DefaultLocalDateTimeAssertions()
fun day(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>
fun dayOfWeek(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, DayOfWeek>
fun month(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>
fun year(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>

class DefaultMapEntryAssertions : MapEntryAssertions

DefaultMapEntryAssertions()
fun <K, V, T : Entry<K, V>> isKeyValue(container: AssertionContainer<T>, key: K, value: V): Assertion
fun <K, T : Entry<K, *>> key(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
fun <V, T : Entry<*, V>> value(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>

class DefaultMapLikeAssertions : MapLikeAssertions

DefaultMapLikeAssertions()
fun <T, K, V> builderContainsInMapLike(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>): MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>
fun <K, T> containsKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
fun <K, T> containsNotKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
fun <K, V, T> getExisting(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, key: K): FeatureExtractorBuilder.ExecutionStep<T, V>

class DefaultMapLikeContainsAssertions : MapLikeContainsAssertions

DefaultMapLikeContainsAssertions()
fun <K, V, T> keyValuePairsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V, T> keyValuePairsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V, T> keyValuePairsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderSearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion

class DefaultMapLikeToIterablePairTransformer : MapLikeToIterablePairTransformer

DefaultMapLikeToIterablePairTransformer(container: AssertionContainer<*>)
fun supportedTypes(): List<String>
fun <K, V> unsafeTransform(mapLike: IterableLike): List<Pair<K, V>>

class DefaultNotChecker : NotChecker

DefaultNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

class DefaultNotChecker : NotChecker

DefaultNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

class DefaultNotChecker : NotChecker

DefaultNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

class DefaultOptionalAssertions : OptionalAssertions

DefaultOptionalAssertions()
fun <T : Optional<*>> isEmpty(container: AssertionContainer<T>): Assertion
fun <E, T : Optional<E>> isPresent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, E>

class DefaultPairAssertions : PairAssertions

DefaultPairAssertions()
fun <K, T : Pair<K, *>> first(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
fun <V, T : Pair<*, V>> second(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>

class DefaultPathAssertions : PathAssertions

DefaultPathAssertions()
fun <T : Path> endsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> endsWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> exists(container: AssertionContainer<T>, linkOption: LinkOption?): Assertion
fun <T : Path> existsNot(container: AssertionContainer<T>, linkOption: LinkOption?): Assertion
fun <T : Path> extension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> fileName(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> fileNameWithoutExtension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> hasDirectoryEntry(container: AssertionContainer<T>, entries: List<String>): Assertion
fun <T : Path> hasSameBinaryContentAs(container: AssertionContainer<T>, targetPath: Path): Assertion
fun <T : Path> hasSameTextualContentAs(container: AssertionContainer<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
fun <T : Path> isAbsolute(container: AssertionContainer<T>): Assertion
fun <T : Path> isDirectory(container: AssertionContainer<T>): Assertion
fun <T : Path> isExecutable(container: AssertionContainer<T>): Assertion
fun <T : Path> isReadable(container: AssertionContainer<T>): Assertion
fun <T : Path> isRegularFile(container: AssertionContainer<T>): Assertion
fun <T : Path> isRelative(container: AssertionContainer<T>): Assertion
fun <T : Path> isWritable(container: AssertionContainer<T>): Assertion
fun <T : Path> parent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, Path>
fun <T : Path> resolve(container: AssertionContainer<T>, other: String): FeatureExtractorBuilder.ExecutionStep<T, Path>
fun <T : Path> startsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> startsWith(container: AssertionContainer<T>, expected: Path): Assertion

class DefaultResultAssertions : ResultAssertions

DefaultResultAssertions()
fun <TExpected : Throwable> isFailureOfType(container: AssertionContainer<out Result<*>>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected>
fun <E, T : Result<E>> isSuccess(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, E>

class DefaultSubjectChanger : SubjectChanger

DefaultSubjectChanger()
fun <T, R> reported(container: AssertionContainer<T>, description: Translatable, representation: Any, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>): Expect<R>
fun <T, R> unreported(container: AssertionContainer<T>, transformation: (T) -> R): Expect<R>

object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType
class DefaultThrowableAssertions : ThrowableAssertions

DefaultThrowableAssertions()
fun <TExpected : Throwable> causeIsA(container: AssertionContainer<out Throwable>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected>

class DefaultTranslationsOf

DefaultTranslationsOf(expected: Translatable, vararg otherExpected: Translatable)
val expected: Translatable
vararg val otherExpected: Array<out Translatable>
fun toList(): List<Translatable>

class DefaultZonedDateTimeAssertions : ZonedDateTimeAssertions

DefaultZonedDateTimeAssertions()
fun day(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>
fun dayOfWeek(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, DayOfWeek>
fun month(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>
fun year(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>

interface DelegatingExpect<T> : Expect<T>

operator fun <T> invoke(assertionHolder: AssertionHolder, maybeSubject: Option<T>): Expect<T>

enum class DescriptionAnyAssertion : StringBasedTranslatable

IS_NOT_SAME
IS_SAME
NOT_TO_BE
TO_BE
val value: String

enum class DescriptionAnyAssertion : StringBasedTranslatable

BECAUSE
IS_A
IS_NONE_OF
IS_NOT_SAME
IS_SAME
NOT_TO_BE
TO_BE
val value: String

enum class DescriptionBasic : StringBasedTranslatable

IS
IS_NOT
val value: String

enum class DescriptionBasic : StringBasedTranslatable

HAS
HAS_NOT
IS
IS_NOT
NONE
NOT_TO
NOT_TO_BE
TO
TO_BE
val value: String
WAS

enum class DescriptionBigDecimalAssertion : StringBasedTranslatable

FAILURE_TO_BE_BUT_NUMERICALLY_EQUAL
IS_EQUAL_INCLUDING_SCALE
IS_NOT_EQUAL_INCLUDING_SCALE
IS_NOT_NUMERICALLY_EQUAL_TO
IS_NUMERICALLY_EQUAL_TO
val value: String

enum class DescriptionBigDecimalAssertion : StringBasedTranslatable

FAILURE_IS_EQUAL_INCLUDING_SCALE_BUT_NUMERICALLY_EQUAL
IS_EQUAL_INCLUDING_SCALE
IS_NOT_EQUAL_INCLUDING_SCALE
IS_NOT_NUMERICALLY_EQUAL_TO
IS_NUMERICALLY_EQUAL_TO
val value: String

enum class DescriptionCharSequenceAssertion : StringBasedTranslatable

AT_LEAST
AT_MOST
CONTAINS
CONTAINS_NOT
EMPTY
ENDS_NOT_WITH
ENDS_WITH
EXACTLY
IGNORING_CASE
NUMBER_OF_OCCURRENCES
STARTS_NOT_WITH
STARTS_WITH
val value: String

enum class DescriptionCharSequenceAssertion : StringBasedTranslatable

AT_LEAST
AT_MOST
BLANK
CONTAINS
CONTAINS_NOT
EMPTY
ENDS_NOT_WITH
ENDS_WITH
EXACTLY
IGNORING_CASE
MATCHES
MISMATCHES
NUMBER_OF_OCCURRENCES
STARTS_NOT_WITH
STARTS_WITH
STRING_MATCHING_REGEX
VALUE
val value: String

enum class DescriptionCollectionAssertion : StringBasedTranslatable

EMPTY
HAS_SIZE
val value: String

enum class DescriptionCollectionAssertion : StringBasedTranslatable

EMPTY
SIZE
val value: String

enum class DescriptionComparableAssertion : StringBasedTranslatable

IS_GREATER_OR_EQUALS
IS_GREATER_THAN
IS_LESS_OR_EQUALS
IS_LESS_THAN
val value: String

enum class DescriptionComparableAssertion : StringBasedTranslatable

IS_EQUAL
IS_GREATER_OR_EQUALS
IS_GREATER_THAN
IS_GREATER_THAN_OR_EQUAL
IS_LESS_OR_EQUALS
IS_LESS_THAN
IS_LESS_THAN_OR_EQUAL
val value: String

enum class DescriptionDateTimeLikeAssertion : StringBasedTranslatable

DAY
DAY_OF_WEEK
IS_AFTER
IS_AFTER_OR_EQUAL
IS_BEFORE
IS_BEFORE_OR_EQUAL
IS_EQUAL_TO
MONTH
SAME_DAY
val value: String
YEAR

enum class DescriptionFloatingPointAssertion : StringBasedTranslatable

FAILURE_DUE_TO_FLOATING_POINT_NUMBER
TO_BE_WITH_ERROR_TOLERANCE
TO_BE_WITH_ERROR_TOLERANCE_EXPLAINED
val value: String

enum class DescriptionFloatingPointAssertion : StringBasedTranslatable

FAILURE_DUE_TO_FLOATING_POINT_NUMBER
TO_BE_WITH_ERROR_TOLERANCE
TO_BE_WITH_ERROR_TOLERANCE_EXPLAINED
val value: String

enum class DescriptionFunLikeAssertion : StringBasedTranslatable

IS_NOT_THROWING_1
IS_NOT_THROWING_2
NO_EXCEPTION_OCCURRED
THREW
THROWN_EXCEPTION_WHEN_CALLED
val value: String

enum class DescriptionIterableAssertion : StringBasedTranslatable

AN_ENTRY_WHICH
AN_ENTRY_WHICH_IS
AT_LEAST
AT_MOST
CANNOT_EVALUATE_SUBJECT_EMPTY_ITERABLE
CANNOT_EVALUATE_SUBJECT_ONLY_NULL
CONTAINS
CONTAINS_NOT
ENTRY_WITH_INDEX
EXACTLY
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
NUMBER_OF_OCCURRENCES
SIZE_EXCEEDED
val value: String
WARNING_ADDITIONAL_ENTRIES
WARNING_MISMATCHES
WARNING_MISMATCHES_ADDITIONAL_ENTRIES

enum class DescriptionIterableAssertion : StringBasedTranslatable

ALL
AN_ELEMENT_WHICH
AN_ELEMENT_WHICH_EQUALS
AN_ENTRY_WHICH
AN_ENTRY_WHICH_IS
AT_LEAST
AT_MOST
CANNOT_EVALUATE_SUBJECT_EMPTY_ITERABLE
CANNOT_EVALUATE_SUBJECT_ONLY_NULL
CONTAINS
CONTAINS_NOT
DUPLICATE_ELEMENTS
ELEMENT_WITH_INDEX
ENTRY_WITH_INDEX
EXACTLY
HAS_ELEMENT
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
IN_ORDER_ONLY_GROUPED
INDEX
INDEX_FROM_TO
NEXT_ELEMENT
NO_ELEMENTS
NUMBER_OF_OCCURRENCES
SIZE_EXCEEDED
val value: String
WARNING_ADDITIONAL_ELEMENTS
WARNING_ADDITIONAL_ENTRIES
WARNING_MISMATCHES
WARNING_MISMATCHES_ADDITIONAL_ELEMENTS
WARNING_MISMATCHES_ADDITIONAL_ENTRIES

enum class DescriptionListAssertion : StringBasedTranslatable

CANNOT_EVALUATE_INDEX_OUT_OF_BOUNDS
INDEX_OUT_OF_BOUNDS
val value: String

enum class DescriptionMapAssertion : StringBasedTranslatable

CANNOT_EVALUATE_KEY_DOES_NOT_EXIST
CONTAINS_IN_ANY_ORDER
CONTAINS_KEY
CONTAINS_NOT_KEY
ENTRY_WITH_KEY
KEY_DOES_NOT_EXIST
SIZE
val value: String

enum class DescriptionMapLikeAssertion : StringBasedTranslatable

CONTAINS
CONTAINS_KEY
CONTAINS_NOT_KEY
ENTRY_WITH_KEY
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
KEY_DOES_NOT_EXIST
val value: String
WARNING_ADDITIONAL_ENTRIES

enum class DescriptionOptionalAssertion : StringBasedTranslatable

EMPTY
GET
IS_NOT_PRESENT
val value: String

enum class DescriptionPathAssertion : StringBasedTranslatable

A_DIRECTORY
A_FILE
A_SYMBOLIC_LINK
A_UNKNOWN_FILE_TYPE
ABSOLUTE_PATH
DOES_NOT_HAVE_PARENT
ENDS_NOT_WITH
ENDS_WITH
EXECUTABLE
EXIST
EXTENSION
FAILURE_DUE_TO_ACCESS_DENIED
FAILURE_DUE_TO_ACCESS_EXCEPTION
FAILURE_DUE_TO_LINK_LOOP
FAILURE_DUE_TO_NO_SUCH_FILE
FAILURE_DUE_TO_PARENT
FAILURE_DUE_TO_PERMISSION_FILE_TYPE_HINT
FAILURE_DUE_TO_WRONG_FILE_TYPE
FILE_NAME
FILE_NAME_WITHOUT_EXTENSION
HAS_SAME_BINARY_CONTENT
HAS_SAME_TEXTUAL_CONTENT
HINT_ACTUAL_ACL_PERMISSIONS
HINT_ACTUAL_POSIX_PERMISSIONS
HINT_CLOSEST_EXISTING_PARENT_DIRECTORY
HINT_FOLLOWED_SYMBOLIC_LINK
HINT_OWNER
HINT_OWNER_AND_GROUP
PARENT
READABLE
RELATIVE_PATH
STARTS_NOT_WITH
STARTS_WITH
val value: String
WRITABLE

class DescriptionRepresentationStepImpl<T> : SubjectChangerBuilder.DescriptionRepresentationStep<T>

DescriptionRepresentationStepImpl(container: AssertionContainer<T>)
val container: AssertionContainer<T>
fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): SubjectChangerBuilder.TransformationStep<T>

enum class DescriptionResultAssertion : StringBasedTranslatable

EXCEPTION
IS_NOT_FAILURE
IS_NOT_SUCCESS
VALUE
val value: String

class DescriptionStepImpl<T> : FeatureExtractorBuilder.DescriptionStep<T>

DescriptionStepImpl(container: AssertionContainer<T>)
val container: AssertionContainer<T>
fun withDescription(translatable: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>

enum class DescriptionThrowableAssertion : StringBasedTranslatable

IS_A
NO_EXCEPTION_OCCURRED
val value: String

enum class DescriptionThrowableAssertion : StringBasedTranslatable

IS_A
IS_NOT_THROWN_1
IS_NOT_THROWN_2
NO_EXCEPTION_OCCURRED
NOT_CAUSED
OCCURRED_EXCEPTION_CAUSE
OCCURRED_EXCEPTION_MESSAGE
OCCURRED_EXCEPTION_PROPERTIES
OCCURRED_EXCEPTION_STACKTRACE
OCCURRED_EXCEPTION_SUPPRESSED
val value: String

enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable

IS_A
val value: String
WARNING_DOWN_CAST_FAILED

enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable

IS_A
val value: String
WARNING_DOWN_CAST_FAILED

interface Descriptive

interface DescriptionOption<R>

fun <R> create(test: () -> Boolean, factory: (() -> Boolean, Translatable, Any) -> R): Descriptive.DescriptionOption<R>
abstract val test: () -> Boolean
open fun withDescriptionAndRepresentation(description: String, representation: Any?): R
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): R

interface FinalStep : AssertionBuilderFinalStep<DescriptiveAssertion>

fun create(test: () -> Boolean, description: Translatable, representation: Any): Descriptive.FinalStep
abstract val description: Translatable
abstract val representation: Any
abstract val test: () -> Boolean

interface HoldsOption

fun create(): Descriptive.HoldsOption
abstract val failing: Descriptive.DescriptionOption<Descriptive.FinalStep>
abstract val holding: Descriptive.DescriptionOption<Descriptive.FinalStep>
abstract fun withTest(test: () -> Boolean): Descriptive.DescriptionOption<Descriptive.FinalStep>
abstract fun <T> withTest(subjectProvider: SubjectProvider<T>, test: (T) -> Boolean): Descriptive.DescriptionOption<Descriptive.FinalStep>

interface DescriptiveAssertion : Assertion

abstract val description: Translatable
open val expected: Any
abstract val representation: Any

interface DescriptiveAssertionWithFailureHint

interface FailureHintSubjectAbsentOption<T> : SubjectBasedOption.AbsentOption<T, Assertion>

fun <T> create(ifDefined: (T) -> Assertion): DescriptiveAssertionWithFailureHint.FailureHintSubjectAbsentOption<T>

interface FailureHintSubjectDefinedOption<T> : SubjectBasedOption.DefinedOption<T, Assertion, DescriptiveAssertionWithFailureHint.FailureHintSubjectAbsentOption<T>>

fun <T> create(): DescriptiveAssertionWithFailureHint.FailureHintSubjectDefinedOption<T>

interface FinalStep : AssertionBuilderFinalStep<Assertion>

fun create(test: () -> Boolean, showHint: () -> Boolean, failureHintFactory: () -> Assertion, description: Translatable, representation: Any): DescriptiveAssertionWithFailureHint.FinalStep
abstract val description: Translatable
abstract val failureHintFactory: () -> Assertion
abstract val representation: Any
abstract val showHint: () -> Boolean
abstract val test: () -> Boolean

interface ShowOption

fun create(test: () -> Boolean, failureHintFactory: () -> Assertion): DescriptiveAssertionWithFailureHint.ShowOption
open fun <T> showBasedOnDefinedSubjectOnlyIf(subjectProvider: SubjectProvider<T>, predicate: (T) -> Boolean): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
open fun <T> showBasedOnSubjectOnlyIf(subjectProvider: SubjectProvider<T>, showSubStep: DescriptiveAssertionWithFailureHint.ShowSubjectDefinedOption<T>.() -> Pair<() -> Boolean, (T) -> Boolean>): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
abstract val showForAnyFailure: Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
abstract fun showOnlyIf(predicate: () -> Boolean): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
open fun <T> showOnlyIfSubjectDefined(subjectProvider: SubjectProvider<T>): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>

interface ShowSubjectAbsentOption<T> : SubjectBasedOption.AbsentOption<T, Boolean>

fun <T> create(ifDefined: (T) -> Boolean): DescriptiveAssertionWithFailureHint.ShowSubjectAbsentOption<T>

interface ShowSubjectDefinedOption<T> : SubjectBasedOption.DefinedOption<T, Boolean, DescriptiveAssertionWithFailureHint.ShowSubjectAbsentOption<T>>

fun <T> create(): DescriptiveAssertionWithFailureHint.ShowSubjectDefinedOption<T>

class DirectoryEntries : VarArgHelper<String>

DirectoryEntries(expected: String, otherExpected: Array<out String>)
val expected: String
val otherExpected: Array<out String>

interface DoNotFilterAssertionGroupType : AssertionGroupType
class DownCaster<T : Any, TSub : T>

DownCaster(failureHandler: AnyTypeTransformation.TypeTransformationFailureHandler<T, TSub>)
fun downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

class Eintraege<in T : Any> : GroupWithoutNullableEntries<((Assert<T>) -> Unit)?>, GroupWithNullableEntries<((Assert<T>) -> Unit)?>, VarArgHelper<((Assert<T>) -> Unit)?>

Eintraege(assertionCreatorOrNull: ((Assert<T>) -> Unit)?, vararg otherAssertionCreatorsOrNulls: ((Assert<T>) -> Unit)?)
val assertionCreatorOrNull: ((Assert<T>) -> Unit)?
val expected: ((Assert<T>) -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<((Assert<T>) -> Unit)?>
val otherExpected: Array<((Assert<T>) -> Unit)?>
fun toList(): List<((Assert<T>) -> Unit)?>

class Eintrag<in T : Any> : GroupWithoutNullableEntries<((Assert<T>) -> Unit)?>, GroupWithNullableEntries<((Assert<T>) -> Unit)?>

Eintrag(assertionCreator: ((Assert<T>) -> Unit)?)
val assertionCreator: ((Assert<T>) -> Unit)?
fun toList(): List<((Assert<T>) -> Unit)?>

sealed class Either<out L, out R>

inline fun <T> fold(fL: (L) -> T, fR: (R) -> T): T
inline fun <T> map(f: (R) -> T): Either<L, T>
fun toOption(): Option<R>

object empty : Keyword
object Empty
object Empty : Keyword
open class EmptyNameAndRepresentationAssertionGroup : AssertionGroup

EmptyNameAndRepresentationAssertionGroup(type: AssertionGroupType, assertions: List<Assertion>)
open val assertions: List<Assertion>
open val description: Translatable
open val representation: Any
open val type: AssertionGroupType

class Entries<T : Any> : GroupWithoutNullableEntries<(Expect<T>.() -> Unit)?>, GroupWithNullableEntries<(Expect<T>.() -> Unit)?>, VarArgHelper<(Expect<T>.() -> Unit)?>

Entries(assertionCreatorOrNull: (Expect<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<T>.() -> Unit)?)
val assertionCreatorOrNull: (Expect<T>.() -> Unit)?
val expected: (Expect<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Expect<T>.() -> Unit)?>
val otherExpected: Array<(Expect<T>.() -> Unit)?>
fun toList(): List<(Expect<T>.() -> Unit)?>

object entries : Keyword
class Entries<T> : GroupWithoutNullableEntries<(Expect<T>.() -> Unit)?>, GroupWithNullableEntries<(Expect<T>.() -> Unit)?>, VarArgHelper<(Expect<T>.() -> Unit)?>

val assertionCreatorOrNull: (Expect<T>.() -> Unit)?
val expected: (Expect<T>.() -> Unit)?
val otherAssertionCreatorsOrNulls: Array<(Expect<T>.() -> Unit)?>
val otherExpected: Array<(Expect<T>.() -> Unit)?>
fun toList(): List<(Expect<T>.() -> Unit)?>

class Entries<in T : Any, out A : ((Assert<T>) -> Unit)?>

Entries(assertionCreator: A, vararg otherAssertionCreators: A)
val assertionCreator: A
vararg val otherAssertionCreators: Array<out A>
fun toList(): List<A>

class Entries<in T : Any> : GroupWithoutNullableEntries<(Assert<T>.() -> Unit)?>, GroupWithNullableEntries<(Assert<T>.() -> Unit)?>, VarArgHelper<(Assert<T>.() -> Unit)?>

Entries(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
val expected: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
val otherExpected: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

class Entries<in T : Any> : GroupWithoutNullableEntries<(Assert<T>.() -> Unit)?>, GroupWithNullableEntries<(Assert<T>.() -> Unit)?>, VarArgHelper<(Assert<T>.() -> Unit)?>

Entries(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
val expected: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
val otherExpected: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

object entries : Keyword
class Entry<T : Any> : GroupWithoutNullableEntries<(Expect<T>.() -> Unit)?>, GroupWithNullableEntries<(Expect<T>.() -> Unit)?>

Entry(assertionCreatorOrNull: (Expect<T>.() -> Unit)?)
val assertionCreatorOrNull: (Expect<T>.() -> Unit)?
fun toList(): List<(Expect<T>.() -> Unit)?>

data class Entry<T : Any> : GroupWithoutNullableEntries<(Expect<T>.() -> Unit)?>, GroupWithNullableEntries<(Expect<T>.() -> Unit)?>

val assertionCreatorOrNull: (Expect<T>.() -> Unit)?
fun toList(): List<(Expect<T>.() -> Unit)?>

class Entry<in T : Any> : GroupWithoutNullableEntries<(Assert<T>.() -> Unit)?>, GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

Entry(assertionCreatorOrNull: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

class Entry<in T : Any> : GroupWithoutNullableEntries<(Assert<T>.() -> Unit)?>, GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

Entry(assertionCreatorOrNull: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

class EntryPointStepImpl<E, T, out S : IterableLikeContains.SearchBehaviour> : EntryPointStepImpl<T, S>, IterableLikeContains.EntryPointStepInternal<E, T, S>

EntryPointStepImpl(container: AssertionContainer<T>, converter: (T) -> Iterable<E>, searchBehaviour: S)
val converter: (T) -> Iterable<E>

class EntryPointStepImpl<K, V, T, out S : MapLikeContains.SearchBehaviour> : EntryPointStepImpl<T, S>, MapLikeContains.EntryPointStepInternal<K, V, T, S>

EntryPointStepImpl(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, searchBehaviour: S)
val converter: (T) -> Map<out K, V>

enum class ErrorMessages : StringBasedTranslatable

AT_LEAST_ONE_ASSERTION_DEFINED
FORGOT_DO_DEFINE_ASSERTION
HINT_AT_LEAST_ONE_ASSERTION_DEFINED
SUBJECT_ACCESSED_TOO_EARLY
val value: String

enum class ErrorMessages : StringBasedTranslatable

AT_LEAST_ONE_ASSERTION_DEFINED
DEDSCRIPTION_BASED_ON_SUBJECT
DESCRIPTION_BASED_ON_SUBJECT
FORGOT_DO_DEFINE_ASSERTION
HINT_AT_LEAST_ONE_ASSERTION_DEFINED
REPRESENTATION_BASED_ON_SUBJECT_NOT_DEFINED
SUBJECT_ACCESSED_TOO_EARLY
val value: String

interface ExactlyChecker : WithTimesChecker

abstract val exactlyCall: (Int) -> String
abstract val nameContainsNotFun: String

interface ExactlyChecker : ExactlyChecker, CharSequenceContains.Checker
interface ExactlyChecker : ExactlyChecker, IterableLikeContains.Checker
interface ExactlyChecker : ExactlyChecker, MapLikeContains.Checker
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ExactlyCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

ExactlyCheckerOptionBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class ExactlyCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

ExactlyCheckerOptionBase(times: Int, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface ExactlyCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
interface ExactlyCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
object executable : Keyword
class ExecutionStepImpl<T, R> : FeatureExtractorBuilder.ExecutionStep<T, R>, BaseTransformationExecutionStep<T, R, FeatureExpect<T, R>>

ExecutionStepImpl(container: AssertionContainer<T>, action: AssertionContainer<T>.() -> FeatureExpect<T, R>, actionAndApply: AssertionContainer<T>.(Expect<R>.() -> Unit) -> Expect<R>)

class ExecutionStepImpl<T, R> : SubjectChangerBuilder.ExecutionStep<T, R>, BaseTransformationExecutionStep<T, R, Expect<R>>

ExecutionStepImpl(container: AssertionContainer<T>, action: AssertionContainer<T>.() -> Expect<R>, actionAndApply: AssertionContainer<T>.(Expect<R>.() -> Unit) -> Expect<R>)

object existing : Keyword
interface Expect<T> : SubjectProvider<T>

abstract fun addAssertion(assertion: Assertion): Expect<T>
abstract fun addAssertionsCreatedBy(assertionCreator: Expect<T>.() -> Unit): Expect<T>
open fun createAndAddAssertion(description: String, expected: Any?, test: (T) -> Boolean): Expect<T>
open fun createAndAddAssertion(description: Translatable, expected: Any?, test: (T) -> Boolean): Expect<T>

interface ExpectBuilder

interface AssertionVerbStep<T>

abstract val maybeSubject: Option<T>
open fun withVerb(verb: String): ExpectBuilder.OptionsStep<T>
abstract fun withVerb(verb: Translatable): ExpectBuilder.OptionsStep<T>

interface FinalStep<T>

abstract val assertionVerb: Translatable
abstract fun build(): RootExpect<T>
fun <T> create(maybeSubject: Option<T>, assertionVerb: Translatable, options: ExpectOptions<T>?): ExpectBuilder.FinalStep<T>
abstract val maybeSubject: Option<T>
abstract val options: ExpectOptions<T>?

fun <T> forSubject(subject: T): ExpectBuilder.AssertionVerbStep<T>
interface OptionsChooser<T>

fun <T> createAndBuild(configuration: ExpectBuilder.OptionsChooser<T>.() -> Unit): ExpectOptions<T>
abstract fun withReporter(reporter: Reporter): Unit
open fun withRepresentation(textRepresentation: String): Unit
abstract fun withRepresentation(representationProvider: (T) -> Any): Unit
open fun withVerb(verb: String): Unit
abstract fun withVerb(verb: Translatable): Unit

interface OptionsStep<T>

abstract val assertionVerb: Translatable
fun <T> create(maybeSubject: Option<T>, assertionVerb: Translatable): ExpectBuilder.OptionsStep<T>
abstract val maybeSubject: Option<T>
open fun withOptions(configuration: ExpectBuilder.OptionsChooser<T>.() -> Unit): ExpectBuilder.FinalStep<T>
abstract fun withOptions(expectOptions: ExpectOptions<T>): ExpectBuilder.FinalStep<T>
abstract fun withoutOptions(): ExpectBuilder.FinalStep<T>

object ExpectImpl

inline val any: AnyAssertionsBuilder
inline val builder: AssertionBuilder
inline fun <T> changeSubject(originalExpect: Expect<T>): SubjectChangerBuilder.KindStep<T>
inline fun <T> changeSubject(originalAssertionContainer: SubjectProvider<T>): SubjectChangerBuilder.DeprecatedKindStep<T>
inline val charSequence: CharSequenceAssertionsBuilder
inline val collection: CollectionAssertionsBuilder
inline val collector: AssertionCollectorBuilder
inline val comparable: ComparableAssertionsBuilder
inline val feature: NewFeatureAssertionsBuilder
inline val floatingPoint: FloatingPointAssertionsBuilder
inline val fun0: Fun0AssertionsBuilder
inline val iterable: IterableAssertionsBuilder
inline val iterator: IteratorAssertionsBuilder
val list: ListAssertionsBuilder
inline val map: MapAssertionsBuilder
inline val pair: PairAssertionsBuilder
inline val throwable: ThrowableAssertionsBuilder

interface ExpectInternal<T> : Expect<T>, AssertionContainer<T>
@DslMarker annotation class ExpectMarker

ExpectMarker()

data class ExpectOptions<T>

ExpectOptions(assertionVerb: Translatable? = null, representationInsteadOfSubject: ((T) -> Any)? = null, reporter: Reporter? = null)
val assertionVerb: Translatable?
fun merge(options: ExpectOptions<T>): ExpectOptions<T>
val reporter: Reporter?
val representationInsteadOfSubject: ((T) -> Any)?
fun toRootExpectOptions(): RootExpectOptions<T>

@Target([AnnotationTarget.FUNCTION, AnnotationTarget.CLASS]) annotation class ExperimentalNewExpectTypes

ExperimentalNewExpectTypes()

@Target([AnnotationTarget.FUNCTION]) annotation class ExperimentalWithOptions

ExperimentalWithOptions()

@Target([AnnotationTarget.FUNCTION]) annotation class ExperimentalWithOptions

ExperimentalWithOptions()

object ExplainingAssertionCollectorOption

inline val doNotThrowIfNoAssertionIsCollected: NonThrowingAssertionCollectorForExplanation
inline val throwIfNoAssertionIsCollected: ThrowingAssertionCollectorForExplanation

interface Explanatory

interface ExplanationOption

fun create(): Explanatory.ExplanationOption
open fun withDescription(translatable: Translatable, arg: Any, vararg otherArgs: Any): Explanatory.FinalStep
open fun withDescription(translatable: Translatable): Explanatory.FinalStep
open fun withDescription(explanation: Any?): Explanatory.FinalStep
open fun withExplanation(translatable: Translatable, arg: Any, vararg otherArgs: Any): Explanatory.FinalStep
open fun withExplanation(description: String): Explanatory.FinalStep
abstract fun withExplanation(explanation: Any?): Explanatory.FinalStep

interface FinalStep : AssertionBuilderFinalStep<ExplanatoryAssertion>

fun create(explanation: Any?): Explanatory.FinalStep
abstract val explanation: Any?

interface ExplanatoryAssertion : Assertion

abstract val explanation: Any?
open fun holds(): Boolean

class ExplanatoryAssertionGroup : EmptyNameAndRepresentationAssertionGroup

fun holds(): Boolean

interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>

fun create(groupType: ExplanatoryAssertionGroupType, explanatoryAssertions: List<Assertion>): ExplanatoryAssertionGroupFinalStep
abstract val explanatoryAssertions: List<Assertion>
abstract val failing: ExplanatoryAssertionGroupFinalStep
abstract val groupType: ExplanatoryAssertionGroupType

interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType
interface ExplanatoryAssertionGroupTypeOption

abstract val withDefaultType: AssertionsOption<DefaultExplanatoryAssertionGroupType, ExplanatoryAssertionGroupFinalStep>
abstract fun withInformationType(withIndent: Boolean): AssertionsOption<InformationAssertionGroupType, ExplanatoryAssertionGroupFinalStep>
abstract fun <T : ExplanatoryAssertionGroupType> withType(groupType: T): AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>
abstract val withWarningType: AssertionsOption<WarningAssertionGroupType, ExplanatoryAssertionGroupFinalStep>

interface ExplanatoryGroup

interface FinalStep : AssertionBuilderFinalStep<AssertionGroup>, ExplanatoryAssertionGroupFinalStep

fun create(groupType: ExplanatoryAssertionGroupType, explanatoryAssertions: List<Assertion>, holds: Boolean = true): ExplanatoryGroup.FinalStep
abstract val explanatoryAssertions: List<Assertion>
open val failing: ExplanatoryGroup.FinalStep
abstract val groupType: ExplanatoryAssertionGroupType

interface GroupTypeOption : ExplanatoryAssertionGroupTypeOption

fun create(): ExplanatoryGroup.GroupTypeOption
abstract val withDefaultType: AssertionsOption<DefaultExplanatoryAssertionGroupType, ExplanatoryGroup.FinalStep>
abstract fun withInformationType(withIndent: Boolean): AssertionsOption<InformationAssertionGroupType, ExplanatoryGroup.FinalStep>
abstract fun <T : ExplanatoryAssertionGroupType> withType(groupType: T): AssertionsOption<T, ExplanatoryGroup.FinalStep>
abstract val withWarningType: AssertionsOption<WarningAssertionGroupType, ExplanatoryGroup.FinalStep>

class ExplanatoryTypeTransformationFailureHandler<T : Any, out TSub : T> : AnyTypeTransformation.TypeTransformationFailureHandler<T, TSub>

ExplanatoryTypeTransformationFailureHandler()
fun createAndAddAssertionToPlant(warningTransformationFailed: Translatable, subjectPlant: BaseAssertionPlant<T?, *>, failingAssertion: Assertion, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

class ExtractedFeaturePostStep<T, R> : PostFinalStep<T, R, FeatureExpect<T, R>>

ExtractedFeaturePostStep(expect: Expect<T>, extract: Expect<T>.() -> FeatureExpect<T, R>, extractAndApply: Expect<T>.(Expect<R>.() -> Unit) -> Expect<R>)

class Failure : IoResult<Nothing>

Failure(path: Path, exception: IOException)
val exception: IOException

class FailureHandlerAdapter<T, R1, R> : SubjectChanger.FailureHandler<T, R>

FailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1)
fun createAssertion(container: AssertionContainer<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion
val failureHandler: SubjectChanger.FailureHandler<R1, R>
val map: (T) -> R1

class FailureHandlerAdapter<T, R1, R> : SubjectChanger.FailureHandler<T, R>

FailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1)
fun createAssertion(originalAssertionContainer: Expect<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion
val failureHandler: SubjectChanger.FailureHandler<R1, R>
val map: (T) -> R1

interface FailureHandlerFactory

abstract fun <S : Any, T : Any> newExplanatory(): AnyTypeTransformation.FailureHandler<S, T>
abstract fun <S : Any, T : Any> newExplanatoryWithHint(showHint: () -> Boolean, failureHintFactory: () -> Assertion): AnyTypeTransformation.FailureHandler<S, T>

class FailureHandlerStepImpl<T, R> : SubjectChangerBuilder.FailureHandlerStep<T, R>

FailureHandlerStepImpl(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>)
val transformation: (T) -> Option<R>
val transformationStep: SubjectChangerBuilder.TransformationStep<T>
fun withDefaultFailureHandler(): SubjectChangerBuilder.FinalStep<T, R>
fun withFailureHandler(failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>

data class Feature<T, R>

val description: String
val extractor: (T) -> R

interface FeatureAssertionGroupType : AssertionGroupType
interface FeatureAssertions

abstract fun <T, R> f0(container: AssertionContainer<T>, f: KFunction1<T, R>): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, R> f1(container: AssertionContainer<T>, f: KFunction2<T, A1, R>, a1: A1): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, R> f2(container: AssertionContainer<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, R> f3(container: AssertionContainer<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, A4, R> f4(container: AssertionContainer<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, A4, A5, R> f5(container: AssertionContainer<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, R> manualFeature(container: AssertionContainer<T>, description: Translatable, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, TProperty> property(container: AssertionContainer<T>, property: KProperty1<in T, TProperty>): FeatureExtractorBuilder.ExecutionStep<T, TProperty>

interface FeatureAssertions

abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlant<R>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>

object FeatureAssertionsBuilder : FeatureAssertions

inline val extractor: FeatureExtractor.DescriptionOption
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
@JvmName("safeReturnValueOf0") inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf0") inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf0") inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf1") inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf1") inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf1") inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf2") inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf2") inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf2") inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf3") inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf3") inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf3") inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf4") inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf4") inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf4") inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf5") inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf5") inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf5") inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>

interface FeatureExpect<T, R> : Expect<R>

operator fun <T, R> invoke(previousExpect: Expect<T>, maybeSubject: Option<R>, description: Translatable, assertions: List<Assertion>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>
operator fun <T, R> invoke(featureExpect: FeatureExpect<T, R>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>

data class FeatureExpectOptions<R>

FeatureExpectOptions(description: Translatable? = null, representationInsteadOfFeature: ((R) -> Any)? = null)
val description: Translatable?
fun merge(options: FeatureExpectOptions<R>): FeatureExpectOptions<R>
val representationInsteadOfFeature: ((R) -> Any)?

interface FeatureExpectOptionsChooser<R>

operator fun <R> invoke(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): FeatureExpectOptions<R>
open fun withDescription(description: String): Unit
abstract fun withDescription(description: Translatable): Unit
open fun withRepresentation(textRepresentation: String): Unit
abstract fun withRepresentation(representationProvider: (R) -> Any): Unit

class FeatureExtractionStepImpl<T> : FeatureExtractorBuilder.FeatureExtractionStep<T>

FeatureExtractionStepImpl(container: AssertionContainer<T>, description: Translatable, representationForFailure: Any)
val container: AssertionContainer<T>
val description: Translatable
val representationForFailure: Any
fun <R> withFeatureExtraction(extraction: (T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>

interface FeatureExtractor

abstract fun <T, R> extract(container: AssertionContainer<T>, description: Translatable, representationForFailure: Any, featureExtraction: (T) -> Option<R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>

interface FeatureExtractor

abstract fun <T, R> extract(originalAssertionContainer: Expect<T>, description: Translatable, representationForFailure: Any, featureExtraction: (T) -> Option<R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>, representationInsteadOfFeature: ((R) -> Any)? = null): FeatureExpect<T, R>

interface FeatureExtractor

val builder: FeatureExtractor.DescriptionOption
interface Creator<TSubject, T : Any> : FeatureExtractor.CreatorLike<TSubject, T, AssertionPlant<T>, CollectingAssertionPlant<T>>
interface CreatorLike<TSubject, T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>>

abstract fun extract(): A
abstract fun extractAndAssertIt(assertionCreator: C.() -> Unit): Assertion
abstract val featureRepresentation: Translatable
abstract val parameterObject: FeatureExtractor.ParameterObject<TSubject, T>

interface CreatorNullable<TSubject, T> : FeatureExtractor.CreatorLike<TSubject, T, AssertionPlantNullable<T>, CollectingAssertionPlantNullable<T>>
interface DescriptionOption

open fun feature(featureRepresentation: () -> String): FeatureExtractor.ParameterObjectOption
open fun methodCall(methodName: String, vararg arguments: Any?): FeatureExtractor.ParameterObjectOption
abstract fun withDescription(translatable: Translatable): FeatureExtractor.ParameterObjectOption

data class ParameterObject<TSubject, T>

ParameterObject(subjectPlant: BaseAssertionPlant<TSubject, *>, extractionNotSuccessful: Translatable, warningCannotEvaluate: Translatable, canBeExtracted: (TSubject) -> Boolean, featureExtraction: (TSubject) -> T)
val canBeExtracted: (TSubject) -> Boolean
val extractionNotSuccessful: Translatable
val featureExtraction: (TSubject) -> T
val subjectPlant: BaseAssertionPlant<TSubject, *>
val warningCannotEvaluate: Translatable

interface ParameterObjectOption

abstract val featureDescription: Translatable
open fun <TSubject : Any, T : Any> withParameterObject(parameterObject: FeatureExtractor.ParameterObject<TSubject, T>): FeatureExtractor.Creator<TSubject, T>
open fun <TSubject : Any, T> withParameterObjectNullable(parameterObject: FeatureExtractor.ParameterObject<TSubject, T>): FeatureExtractor.CreatorNullable<TSubject, T>

interface FeatureExtractorBuilder

interface DescriptionStep<T>

abstract val container: AssertionContainer<T>
operator fun <T> invoke(container: AssertionContainer<T>): FeatureExtractorBuilder.DescriptionStep<T>
open fun methodCall(methodName: String, vararg arguments: Any?): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
open fun withDescription(description: String): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
abstract fun withDescription(translatable: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>

interface ExecutionStep<T, R> : TransformationExecutionStep<T, R, FeatureExpect<T, R>>

operator fun <T, R> invoke(container: AssertionContainer<T>, action: (AssertionContainer<T>) -> FeatureExpect<T, R>, actionAndApply: (AssertionContainer<T>, Expect<R>.() -> Unit) -> Expect<R>): FeatureExtractorBuilder.ExecutionStep<T, R>

interface FeatureExtractionStep<T>

abstract val container: AssertionContainer<T>
abstract val description: Translatable
operator fun <T> invoke(container: AssertionContainer<T>, description: Translatable, representationForFailure: Any): FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract val representationForFailure: Any
abstract fun <R> withFeatureExtraction(extraction: (subject: T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>

interface FinalStep<T, R>

abstract fun build(): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract val featureExpectOptions: FeatureExpectOptions<R>?
abstract val featureExtraction: (T) -> Option<R>
abstract val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
operator fun <T, R> invoke(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExtractorBuilder.FinalStep<T, R>

operator fun <T> invoke(assertionContainer: AssertionContainer<T>): FeatureExtractorBuilder.DescriptionStep<T>
interface OptionsStep<T, R>

abstract val featureExtraction: (T) -> Option<R>
abstract val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
operator fun <T, R> invoke(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>
open fun withOptions(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): FeatureExtractorBuilder.FinalStep<T, R>
abstract fun withOptions(expectOptions: FeatureExpectOptions<R>): FeatureExtractorBuilder.FinalStep<T, R>
abstract fun withoutOptions(): FeatureExtractorBuilder.FinalStep<T, R>

interface RepresentationInCaseOfFailureStep<T>

abstract val container: AssertionContainer<T>
abstract val description: Translatable
operator fun <T> invoke(container: AssertionContainer<T>, description: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
open fun withRepresentationForFailure(representationProvider: () -> Any?): FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract fun withRepresentationForFailure(representation: Any): FeatureExtractorBuilder.FeatureExtractionStep<T>

interface FeatureExtractorBuilder

fun <T> create(originalAssertionContainer: Expect<T>): FeatureExtractorBuilder.DescriptionStep<T>
interface DescriptionStep<T>

fun <T> create(originalAssertionContainer: Expect<T>): FeatureExtractorBuilder.DescriptionStep<T>
open fun methodCall(methodName: String, vararg arguments: Any?): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
abstract val originalAssertionContainer: Expect<T>
open fun withDescription(description: String): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
abstract fun withDescription(translatable: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>

interface FeatureExtractionStep<T>

fun <T> create(originalAssertionContainer: Expect<T>, description: Translatable, representationForFailure: Any): FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract val description: Translatable
abstract val originalAssertionContainer: Expect<T>
abstract val representationForFailure: Any
abstract fun <R> withFeatureExtraction(extraction: (subject: T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>

interface FinalStep<T, R>

abstract fun build(): ExtractedFeaturePostStep<T, R>
fun <T, R> create(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>, featureOptions: FeatureOptions<R>?): FeatureExtractorBuilder.FinalStep<T, R>
abstract val featureExtraction: (T) -> Option<R>
abstract val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract val featureOptions: FeatureOptions<R>?

interface OptionsChooser<R>

fun <R> createAndBuild(configuration: FeatureExtractorBuilder.OptionsChooser<R>.() -> Unit): FeatureOptions<R>
open fun withDescription(description: String): Unit
abstract fun withDescription(description: Translatable): Unit
open fun withRepresentation(textRepresentation: String): Unit
abstract fun withRepresentation(representationProvider: (R) -> Any): Unit

interface OptionsStep<T, R>

fun <T, R> create(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>
abstract val featureExtraction: (T) -> Option<R>
abstract val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
open fun withOptions(configuration: FeatureExtractorBuilder.OptionsChooser<R>.() -> Unit): FeatureExtractorBuilder.FinalStep<T, R>
abstract fun withOptions(expectOptions: FeatureOptions<R>): FeatureExtractorBuilder.FinalStep<T, R>
abstract fun withoutOptions(): FeatureExtractorBuilder.FinalStep<T, R>

interface RepresentationInCaseOfFailureStep<T>

fun <T> create(originalAssertionContainer: Expect<T>, description: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
abstract val description: Translatable
abstract val originalAssertionContainer: Expect<T>
open fun withRepresentationForFailure(representationProvider: () -> Any?): FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract fun withRepresentationForFailure(representation: Any): FeatureExtractorBuilder.FeatureExtractionStep<T>

interface FeatureExtractorCreatorFactory

abstract fun <TSubject : Any, T : Any> create(featureRepresentation: Translatable, parameterObject: FeatureExtractor.ParameterObject<TSubject, T>): FeatureExtractor.Creator<TSubject, T>
abstract fun <TSubject : Any, T> createNullable(featureRepresentation: Translatable, parameterObject: FeatureExtractor.ParameterObject<TSubject, T>): FeatureExtractor.CreatorNullable<TSubject, T>

data class FeatureOptions<R>

FeatureOptions(description: Translatable? = null, representationInsteadOfFeature: ((R) -> Any)? = null)
val description: Translatable?
fun merge(options: FeatureOptions<R>): FeatureOptions<R>
val representationInsteadOfFeature: ((R) -> Any)?
fun toFeatureExpectOptions(): FeatureExpectOptions<R>

data class FeatureWithCreator<T, R>

val assertionCreator: Expect<R>.() -> Unit
val description: String
val extractor: (T) -> R

class FinalStepImpl<T, R> : FeatureExtractorBuilder.FinalStep<T, R>

FinalStepImpl(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>, featureExpectOptions: FeatureExpectOptions<R>)
fun build(): FeatureExtractorBuilder.ExecutionStep<T, R>
val featureExpectOptions: FeatureExpectOptions<R>
val featureExtraction: (T) -> Option<R>
val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>

class FinalStepImpl<T, R> : SubjectChangerBuilder.FinalStep<T, R>

FinalStepImpl(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>)
fun build(): SubjectChangerBuilder.ExecutionStep<T, R>
val failureHandler: SubjectChanger.FailureHandler<T, R>
val transformation: (T) -> Option<R>
val transformationStep: SubjectChangerBuilder.TransformationStep<T>

interface FixedClaimGroup

interface FinalStep : BasicAssertionGroupFinalStep

fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>, holds: Boolean): FixedClaimGroup.FinalStep
abstract val holds: Boolean

interface GroupTypeOption : FixedClaimLikeGroup.GroupTypeOption<FixedClaimGroup.FinalStep>

fun create(): FixedClaimGroup.GroupTypeOption

interface HoldsOption<T : AssertionGroupType> : FixedClaimLikeGroup.HoldsOption<T, FixedClaimGroup.FinalStep>

fun <T : AssertionGroupType> create(groupType: T): FixedClaimGroup.HoldsOption<T>

interface FixedClaimLikeGroup

interface GroupTypeOption<R>

open val withFeatureType: FixedClaimLikeGroup.HoldsOption<FeatureAssertionGroupType, R>
open val withListType: FixedClaimLikeGroup.HoldsOption<ListAssertionGroupType, R>
abstract fun <T : AssertionGroupType> withType(groupType: T): FixedClaimLikeGroup.HoldsOption<T, R>

interface HoldsOption<T : AssertionGroupType, R>

abstract val failing: AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, R>>
abstract val groupType: T
abstract val holding: AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, R>>
abstract fun withClaim(holds: Boolean): AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, R>>

interface FloatingPointAssertions

abstract fun toBeWithErrorTolerance(container: AssertionContainer<Float>, expected: Float, tolerance: Float): Assertion
abstract fun toBeWithErrorTolerance(container: AssertionContainer<Double>, expected: Double, tolerance: Double): Assertion

expect interface FloatingPointAssertions : FloatingPointAssertionsCommon

abstract fun <T : BigDecimal> toBeWithErrorTolerance(subjectProvider: SubjectProvider<T>, expected: T, tolerance: T): Assertion

expect object FloatingPointAssertionsBuilder : FloatingPointAssertions

inline fun toBeWithErrorTolerance(subjectProvider: SubjectProvider<Float>, expected: Float, tolerance: Float): Assertion
inline fun toBeWithErrorTolerance(subjectProvider: SubjectProvider<Double>, expected: Double, tolerance: Double): Assertion
inline fun <T : BigDecimal> toBeWithErrorTolerance(subjectProvider: SubjectProvider<T>, expected: T, tolerance: T): Assertion

interface FloatingPointAssertionsCommon

abstract fun toBeWithErrorTolerance(subjectProvider: SubjectProvider<Float>, expected: Float, tolerance: Float): Assertion
abstract fun toBeWithErrorTolerance(subjectProvider: SubjectProvider<Double>, expected: Double, tolerance: Double): Assertion

interface FloatingPointJvmAssertions

abstract fun <T : BigDecimal> toBeWithErrorTolerance(container: AssertionContainer<T>, expected: BigDecimal, tolerance: BigDecimal): Assertion

interface Fun0Assertions

abstract fun <R, T : () -> R> notToThrow(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<*, R>
abstract fun <TExpected : Throwable> toThrow(container: AssertionContainer<() -> Any?>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<*, TExpected>

interface Fun0Assertions

abstract fun <R, T : () -> R> isNotThrowing(expect: Expect<T>): ChangedSubjectPostStep<*, R>
abstract fun <TExpected : Throwable> isThrowing(expect: Expect<() -> Any?>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<*, TExpected>

object Fun0AssertionsBuilder : Fun0Assertions

inline fun <R, T : () -> R> isNotThrowing(expect: Expect<T>): ChangedSubjectPostStep<*, R>
inline fun <TExpected : Throwable> isThrowing(expect: Expect<() -> Any?>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<*, TExpected>

object group : Keyword
object group : Keyword
interface Group<out T>

abstract fun toList(): List<T>

interface GroupWithNullableEntries<out T> : Group<T>
interface GroupWithoutNullableEntries<out T> : Group<T>
interface HoldsStep<R>

abstract val failing: R
abstract val holding: R
abstract fun withTest(test: () -> Boolean): R
abstract fun <T> withTest(subjectProvider: SubjectProvider<T>, test: (T) -> Boolean): R

interface IAtriumFactory

abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subject: T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: AssertionPlantWithCommonFields.CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subject: T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: AssertionPlantWithCommonFields.CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, vararg fallbackLocales: Locale): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit

class IgnoringCaseIndexSearcher : CharSequenceContains.Searcher<IgnoringCaseSearchBehaviour, Any>

IgnoringCaseIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class IgnoringCaseRegexSearcher : CharSequenceContains.Searcher<IgnoringCaseSearchBehaviour, String>

IgnoringCaseRegexSearcher()
fun search(searchIn: CharSequence, searchFor: String): Int

interface IgnoringCaseSearchBehaviour : CharSequenceContains.SearchBehaviour
interface IgnoringCaseSearchBehaviour : CharSequenceContains.SearchBehaviour
class IgnoringCaseSearchBehaviourImpl : IgnoringCaseSearchBehaviour

IgnoringCaseSearchBehaviourImpl(previousBehaviour: NoOpSearchBehaviour)
fun decorateDescription(description: Translatable): Translatable

class InAnyOrderEntriesAssertionCreator<E : Any, T> : ContainsAssertionCreator<T, List<E?>, (Expect<E>.() -> Unit)?, IterableLikeContains.Checker>, IterableLikeContains.Creator<T, (Expect<E>.() -> Unit)?>

InAnyOrderEntriesAssertionCreator(converter: (T) -> Iterable<E?>, searchBehaviour: InAnyOrderSearchBehaviour, checkers: List<IterableLikeContains.Checker>)
protected val descriptionContains: Translatable
protected fun makeSubjectMultipleTimesConsumable(container: AssertionContainer<T>): AssertionContainer<List<E?>>
protected fun searchAndCreateAssertion(multiConsumableContainer: AssertionContainer<List<E?>>, searchCriterion: (Expect<E>.() -> Unit)?, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

abstract class InAnyOrderOnlyAssertionCreator<E, T, in SC> : IterableLikeContains.Creator<T, SC>

InAnyOrderOnlyAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InAnyOrderOnlySearchBehaviour)
protected abstract fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: SC, list: MutableList<E?>): Pair<Boolean, Assertion>
fun createAssertionGroup(container: AssertionContainer<T>, searchCriteria: List<SC>): AssertionGroup

class InAnyOrderOnlyEntriesAssertionCreator<E : Any, T> : InAnyOrderOnlyAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>

InAnyOrderOnlyEntriesAssertionCreator(converter: (T) -> Iterable<E?>, searchBehaviour: InAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: (Expect<E>.() -> Unit)?, list: MutableList<E?>): Pair<Boolean, Assertion>

interface InAnyOrderOnlySearchBehaviour : IterableLikeContains.SearchBehaviour
interface InAnyOrderOnlySearchBehaviour : MapLikeContains.SearchBehaviour
interface InAnyOrderOnlySearchBehaviour : IterableContains.SearchBehaviour
class InAnyOrderOnlySearchBehaviourImpl : InAnyOrderOnlySearchBehaviour

InAnyOrderOnlySearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InAnyOrderOnlySearchBehaviourImpl : InAnyOrderOnlySearchBehaviour

InAnyOrderOnlySearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InAnyOrderOnlyValuesAssertionCreator<E, T> : InAnyOrderOnlyAssertionCreator<E, T, E>

InAnyOrderOnlyValuesAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: E, list: MutableList<E?>): Pair<Boolean, Assertion>

interface InAnyOrderSearchBehaviour : IterableLikeContains.SearchBehaviour
interface InAnyOrderSearchBehaviour : MapLikeContains.SearchBehaviour
interface InAnyOrderSearchBehaviour : IterableContains.SearchBehaviour
class InAnyOrderSearchBehaviourImpl : InAnyOrderSearchBehaviour

InAnyOrderSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InAnyOrderSearchBehaviourImpl : InAnyOrderSearchBehaviour

InAnyOrderSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InAnyOrderValuesAssertionCreator<SC, T> : ContainsObjectsAssertionCreator<T, List<SC>, SC, InAnyOrderSearchBehaviour, IterableLikeContains.Checker>, IterableLikeContains.Creator<T, SC>

InAnyOrderValuesAssertionCreator(converter: (T) -> Iterable<SC>, searchBehaviour: InAnyOrderSearchBehaviour, checkers: List<IterableLikeContains.Checker>)
fun decorateAssertion(container: AssertionContainer<List<SC>>, featureAssertion: Assertion): List<Assertion>
protected val descriptionContains: Translatable
protected val descriptionNumberOfOccurrences: Translatable
protected fun getAssertionGroupType(): AssertionGroupType
protected val groupDescription: Translatable
protected fun makeSubjectMultipleTimesConsumable(container: AssertionContainer<T>): AssertionContainer<List<SC>>
protected fun search(multiConsumableContainer: AssertionContainer<List<SC>>, searchCriterion: SC): Int

class IndentAssertionGroup : EmptyNameAndRepresentationAssertionGroup

IndentAssertionGroup(assertions: List<Assertion>)

interface IndentAssertionGroupType : AssertionGroupType
data class Index

Index(index: Int)
val index: Int

class IndexSearcher : CharSequenceContains.Searcher<NoOpSearchBehaviour, Any>

IndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

data class IndexWithCreator<E>

val assertionCreator: Expect<E>.() -> Unit
val index: Int

data class InformationAssertionGroupType : ExplanatoryAssertionGroupType

InformationAssertionGroupType(withIndent: Boolean)
val withIndent: Boolean

abstract class InOrderOnlyAssertionCreator<E, T, SC> : InOrderOnlyBaseAssertionCreator<E, T, SC>, InOrderOnlyMatcher<E, SC>

InOrderOnlyAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InOrderOnlySearchBehaviour)
protected open fun Expect<List<E>>.addAssertionsAndReturnIndex(searchCriteria: List<SC>): Int

abstract class InOrderOnlyBaseAssertionCreator<E, T, SC> : IterableLikeContains.Creator<T, SC>

InOrderOnlyBaseAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: IterableLikeContains.SearchBehaviour)
protected abstract fun Expect<List<E>>.addAssertionsAndReturnIndex(searchCriteria: List<SC>): Int
fun createAssertionGroup(container: AssertionContainer<T>, searchCriteria: List<SC>): AssertionGroup

class InOrderOnlyEntriesAssertionCreator<E : Any, T> : InOrderOnlyAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>, InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>

InOrderOnlyEntriesAssertionCreator(converter: (T) -> Iterable<E?>, searchBehaviour: InOrderOnlySearchBehaviour)

class InOrderOnlyEntriesMatcher<E : Any> : InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>

InOrderOnlyEntriesMatcher()
fun elementAssertionCreator(maybeElement: Option<E?>, searchCriterion: (Expect<E>.() -> Unit)?): Assertion

abstract class InOrderOnlyGroupedAssertionCreator<E, T, SC> : InOrderOnlyBaseAssertionCreator<E, T, List<SC>>, InOrderOnlyMatcher<E, SC>

InOrderOnlyGroupedAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InOrderOnlyGroupedSearchBehaviour)
protected fun Expect<List<E>>.addAssertionsAndReturnIndex(searchCriteria: List<List<SC>>): Int
protected abstract fun Expect<List<E>>.addSublistAssertion(groupOfSearchCriteria: List<SC>): Unit

class InOrderOnlyGroupedEntriesAssertionCreator<E : Any, T> : InOrderOnlyGroupedAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>, InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>

InOrderOnlyGroupedEntriesAssertionCreator(converter: (T) -> Iterable<E?>, searchBehaviour: InOrderOnlyGroupedSearchBehaviour)
protected fun Expect<List<E?>>.addSublistAssertion(groupOfSearchCriteria: List<(Expect<E>.() -> Unit)?>): Unit

interface InOrderOnlyGroupedSearchBehaviour : IterableLikeContains.SearchBehaviour
interface InOrderOnlyGroupedSearchBehaviour : IterableContains.SearchBehaviour
class InOrderOnlyGroupedSearchBehaviourImpl : InOrderOnlyGroupedSearchBehaviour

InOrderOnlyGroupedSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderOnlyGroupedValuesAssertionCreator<E, T> : InOrderOnlyGroupedAssertionCreator<E, T, E>, InOrderOnlyMatcher<E, E>

InOrderOnlyGroupedValuesAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InOrderOnlyGroupedSearchBehaviour)
protected fun Expect<List<E>>.addSublistAssertion(groupOfSearchCriteria: List<E>): Unit

interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
class InOrderOnlyGroupedWithinSearchBehaviourImpl : InOrderOnlyGroupedWithinSearchBehaviour

InOrderOnlyGroupedWithinSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

interface InOrderOnlyMatcher<E, SC>

open fun Expect<List<E>>.addSingleEntryAssertion(currentIndex: Int, searchCriterion: SC, translatableIndex: DescriptionIterableAssertion): Unit
abstract fun elementAssertionCreator(maybeElement: Option<E>, searchCriterion: SC): Assertion

interface InOrderOnlySearchBehaviour : IterableLikeContains.SearchBehaviour
interface InOrderOnlySearchBehaviour : MapLikeContains.SearchBehaviour
interface InOrderOnlySearchBehaviour : IterableContains.SearchBehaviour
class InOrderOnlySearchBehaviourImpl : InOrderOnlySearchBehaviour

InOrderOnlySearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderOnlySearchBehaviourImpl : InOrderOnlySearchBehaviour

InOrderOnlySearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderOnlyValueMatcher<E> : InOrderOnlyMatcher<E, E>

InOrderOnlyValueMatcher()
fun elementAssertionCreator(maybeElement: Option<E>, searchCriterion: E): Assertion

class InOrderOnlyValuesAssertionCreator<E, T> : InOrderOnlyAssertionCreator<E, T, E>, InOrderOnlyMatcher<E, E>

InOrderOnlyValuesAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InOrderOnlySearchBehaviour)

interface InOrderSearchBehaviour : IterableLikeContains.SearchBehaviour
interface InOrderSearchBehaviour : MapLikeContains.SearchBehaviour
interface InOrderSearchBehaviour : IterableContains.SearchBehaviour
class InOrderSearchBehaviourImpl : InOrderSearchBehaviour

InOrderSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderSearchBehaviourImpl : InOrderSearchBehaviour

InOrderSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InvisibleAssertionGroup : EmptyNameAndRepresentationAssertionGroup
object InvisibleAssertionGroupType : AssertionGroupType
sealed class IoResult<out T>

val path: Path

interface IterableAssertions

abstract fun <E : Any, T : Iterable<E?>> all(expect: Expect<T>, assertionCreator: (Expect<E>.() -> Unit)?): Assertion
abstract fun <E : Any> all(plant: AssertionPlant<Iterable<E?>>, assertionCreator: (AssertionPlant<E>.() -> Unit)?): Assertion
abstract fun <E, T : Iterable<E>> containsBuilder(subjectProvider: SubjectProvider<T>): IterableContains.Builder<E, T, NoOpSearchBehaviour>
abstract fun <E, T : Iterable<E>> containsNotBuilder(subjectProvider: SubjectProvider<T>): IterableContains.Builder<E, T, NotSearchBehaviour>
abstract fun <E, T : Iterable<E>> hasNext(expect: Expect<T>): Assertion
abstract fun <E, T : Iterable<E>> hasNotNext(expect: Expect<T>): Assertion
abstract fun <E : Comparable<E>, T : Iterable<E>> max(expect: Expect<T>): ExtractedFeaturePostStep<T, E>
abstract fun <E : Comparable<E>, T : Iterable<E>> min(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

object IterableAssertionsBuilder : IterableAssertions

inline fun <E : Any, T : Iterable<E?>> all(expect: Expect<T>, noinline assertionCreator: (Expect<E>.() -> Unit)?): Assertion
inline fun <E : Any> all(plant: AssertionPlant<Iterable<E?>>, noinline assertionCreator: (AssertionPlant<E>.() -> Unit)?): Assertion
inline val contains: IterableContainsAssertionsBuilder
inline fun <E, T : Iterable<E>> containsBuilder(subjectProvider: SubjectProvider<T>): IterableContains.Builder<E, T, NoOpSearchBehaviour>
inline fun <E, T : Iterable<E>> containsNotBuilder(subjectProvider: SubjectProvider<T>): IterableContains.Builder<E, T, NotSearchBehaviour>
inline fun <E, T : Iterable<E>> hasNext(expect: Expect<T>): Assertion
inline fun <E, T : Iterable<E>> hasNotNext(expect: Expect<T>): Assertion
inline fun <E : Comparable<E>, T : Iterable<E>> max(expect: Expect<T>): ExtractedFeaturePostStep<T, E>
inline fun <E : Comparable<E>, T : Iterable<E>> min(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

interface IterableContains

interface Builder<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : Contains.Builder<T, S>
interface Checker : Contains.Checker
interface CheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : Contains.CheckerOption<T, S, IterableContains.Checker, IterableContains.Builder<E, T, S>>
interface Creator<in T : Iterable<*>, in SC> : Contains.Creator<T, SC>
interface SearchBehaviour : Contains.SearchBehaviour

interface IterableContains

interface Checker : Contains.Checker, IterableContains.Checker
interface Creator<in T : Iterable<*>, in S> : Contains.Creator<T, S>, IterableContains.Creator<T, S>
interface SearchBehaviour : Contains.SearchBehaviour, IterableContains.SearchBehaviour

interface IterableContainsAssertions

abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnlyWithAssert(builder: IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderWithAssert(checkerOption: IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGroupedWithAssert(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(AssertionPlant<E>.() -> Unit)?>>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyWithAssert(builder: IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnly(builder: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

object IterableContainsAssertionsBuilder : IterableContainsAssertions

inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnlyWithAssert(builder: IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderWithAssert(checkerOption: IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGroupedWithAssert(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(AssertionPlant<E>.() -> Unit)?>>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyWithAssert(builder: IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
inline val searchBehaviours: IterableContainsSearchBehaviourFactoryBuilder
inline fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
inline fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
inline fun <E, T : Iterable<E>> valuesInOrderOnly(builder: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
inline fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

class IterableContainsAtLeastChecker : IterableContainsChecker

IterableContainsAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsAtLeastCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsAtLeastCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

class IterableContainsAtMostChecker : IterableContainsChecker

IterableContainsAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsAtMostCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

open class IterableContainsBuilder<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : ContainsBuilder<T, S>, IterableContains.Builder<E, T, S>

IterableContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsButAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilderBase<E, T, S>, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

abstract class IterableContainsChecker : ContainsChecker, IterableContains.Checker

IterableContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)

interface IterableContainsCheckerBuilder<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : ContainsCheckerBuilder<T, S, IterableContains.Checker, IterableContains.Builder<E, T, S>>, IterableContains.CheckerOption<E, T, S>
class IterableContainsExactlyChecker : IterableContainsChecker

IterableContainsExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsExactlyCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsExactlyCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

open class IterableContainsInAnyOrderEntriesAssertionCreator<E : Any, T : Iterable<E?>> : ContainsAssertionCreator<T, (AssertionPlant<E>.() -> Unit)?, IterableContains.Checker>, IterableContains.Creator<T, (AssertionPlant<E>.() -> Unit)?>

IterableContainsInAnyOrderEntriesAssertionCreator(searchBehaviour: IterableContainsInAnyOrderSearchBehaviour, checkers: List<IterableContains.Checker>)
protected fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected fun searchAndCreateAssertion(subjectProvider: SubjectProvider<T>, searchCriterion: (AssertionPlant<E>.() -> Unit)?, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

class IterableContainsInAnyOrderObjectsAssertionCreator<S, T : Iterable<S>> : ContainsObjectsAssertionCreator<T, S, IterableContainsInAnyOrderSearchBehaviour, IterableContains.Checker>, IterableContains.Creator<T, S>

IterableContainsInAnyOrderObjectsAssertionCreator(searchBehaviour: IterableContainsInAnyOrderSearchBehaviour, checkers: List<IterableContains.Checker>)
protected val descriptionContains: DescriptionIterableAssertion
protected val descriptionNumberOfOccurrences: DescriptionIterableAssertion
protected fun search(subjectProvider: SubjectProvider<T>, searchCriterion: S): Int

abstract class IterableContainsInAnyOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : IterableContains.Creator<T, SC>

IterableContainsInAnyOrderOnlyAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected abstract fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: SC, list: MutableList<E?>): Pair<Boolean, Assertion>
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: SC, otherSearchCriteria: Array<out SC>): AssertionGroup
fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriteria: List<SC>): AssertionGroup

class IterableContainsInAnyOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, (AssertionPlant<E>.() -> Unit)?>

IterableContainsInAnyOrderOnlyEntriesAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: (AssertionPlant<E>.() -> Unit)?, list: MutableList<E?>): Pair<Boolean, Assertion>

class IterableContainsInAnyOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, E>

IterableContainsInAnyOrderOnlyObjectsAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: E, list: MutableList<E?>): Pair<Boolean, Assertion>

open class IterableContainsInAnyOrderOnlySearchBehaviour : IterableContains.SearchBehaviour, InAnyOrderOnlySearchBehaviour

IterableContainsInAnyOrderOnlySearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInAnyOrderSearchBehaviour : IterableContains.SearchBehaviour, InAnyOrderSearchBehaviour

IterableContainsInAnyOrderSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

abstract class IterableContainsInOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : IterableContains.Creator<T, SC>

IterableContainsInOrderOnlyAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: SC, otherSearchCriteria: Array<out SC>): AssertionGroup
fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriteria: List<SC>): AssertionGroup
abstract fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: SC, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
abstract fun matches(actual: E?, searchCriterion: SC): Boolean

class IterableContainsInOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, (AssertionPlant<E>.() -> Unit)?>

IterableContainsInOrderOnlyEntriesAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: (AssertionPlant<E>.() -> Unit)?, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
fun matches(actual: E?, searchCriterion: (AssertionPlant<E>.() -> Unit)?): Boolean

class IterableContainsInOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, E>

IterableContainsInOrderOnlyObjectsAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: E, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
fun matches(actual: E?, searchCriterion: E): Boolean

open class IterableContainsInOrderOnlySearchBehaviour : IterableContains.SearchBehaviour, InOrderOnlySearchBehaviour

IterableContainsInOrderOnlySearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInOrderSearchBehaviour : IterableContains.SearchBehaviour, InOrderSearchBehaviour

IterableContainsInOrderSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

class IterableContainsNoOpCheckerBuilder<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNoOpCheckerBuilder(containsBuilder: IterableContainsBuilder<E, T, S>)
val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContainsBuilder<E, T, S>

open class IterableContainsNoOpSearchBehaviour : IterableContains.SearchBehaviour, NoOpSearchBehaviour

IterableContainsNoOpSearchBehaviour()

class IterableContainsNotChecker : IterableContains.Checker

IterableContainsNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsNotCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNotCheckerBuilderBase(containsBuilder: IterableContainsBuilder<E, T, S>)
open val checkers: List<IterableContainsNotChecker>
open val containsBuilder: IterableContainsBuilder<E, T, S>

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

abstract class IterableContainsNotOrAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNotOrAtMostCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

open class IterableContainsNotSearchBehaviour : IterableContainsInAnyOrderSearchBehaviour, NotSearchBehaviour

IterableContainsNotSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

object IterableContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory

inline fun <E, T : Iterable<E>> inAnyOrder(builder: IterableContains.Builder<E, T, NoOpSearchBehaviour>): IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
inline fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>): IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
inline fun <E, T : Iterable<E>> inOrder(builder: IterableContains.Builder<E, T, NoOpSearchBehaviour>): IterableContains.Builder<E, T, InOrderSearchBehaviour>
inline fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContains.Builder<E, T, InOrderSearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
inline fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
inline fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

typealias IterableLike = Any
typealias IterableLike = Any
interface IterableLikeAssertions

abstract fun <T, E> all(container: AssertionContainer<T>, converter: (T) -> Iterable<E?>, assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Assertion
abstract fun <T, E> builderContainsInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>
abstract fun <T, E> builderContainsNotInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): NotCheckerStep<E, T, NotSearchBehaviour>
abstract fun <T, E> containsNoDuplicates(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E> hasNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E> hasNotNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E : Comparable<E>> max(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
abstract fun <T, E : Comparable<E>> min(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>

interface IterableLikeContains

interface Checker : Contains.Checker
interface CheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.CheckerStep<T, S, IterableLikeContains.Checker, IterableLikeContains.EntryPointStep<E, T, S>>
interface CheckerStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>, IterableLikeContains.CheckerStepLogic<E, T, S>
interface CheckerStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.CheckerStepLogic<T, S, IterableLikeContains.Checker, IterableLikeContains.EntryPointStepLogic<E, T, S>>
interface Creator<T, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.EntryPointStep<E, T, S>, IterableLikeContains.EntryPointStepLogic<E, T, S>
interface EntryPointStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>

abstract val converter: (T) -> Iterable<E>
open fun <S2 : IterableLikeContains.SearchBehaviour> withSearchBehaviour(searchBehaviour: S2): IterableLikeContains.EntryPointStep<E, T, S2>

interface SearchBehaviour : Contains.SearchBehaviour

interface IterableLikeContainsAssertions

abstract fun <E : Any, T> entriesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T> entriesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T> entriesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>): Assertion
abstract fun <E, T> valuesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T> valuesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T> valuesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

interface IterableLikeContainsInAnyOrderAssertions

abstract fun <E : Any, T> entries(checkerStepLogic: IterableLikeContains.CheckerStepLogic<out E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E, T> values(checkerStepLogic: IterableLikeContains.CheckerStepLogic<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion

interface IterableLikeToIterableTransformer

abstract fun supportedTypes(): List<String>
abstract fun <T> unsafeTransform(iterableLike: IterableLike): Iterable<T>

interface IteratorAssertions

abstract fun <E, T : Iterator<E>> hasNext(container: AssertionContainer<T>): Assertion
abstract fun <E, T : Iterator<E>> hasNotNext(container: AssertionContainer<T>): Assertion

interface IteratorAssertions

abstract fun <E, T : Iterator<E>> hasNext(expect: Expect<T>): Assertion
abstract fun <E, T : Iterator<E>> hasNotNext(expect: Expect<T>): Assertion

object IteratorAssertionsBuilder : IteratorAssertions

inline fun <E, T : Iterator<E>> hasNext(expect: Expect<T>): Assertion
inline fun <E, T : Iterator<E>> hasNotNext(expect: Expect<T>): Assertion

java.lang.StringBuilder

expect fun StringBuilder.appendln(): StringBuilder

java.nio.file.Path

inline fun <T> Path.runCatchingIo(block: Path.() -> T): IoResult<T>

java.util.Locale

fun Locale.toAtriumLocale(): Locale

data class Key<out K>

Key(key: K)
val key: K

data class KeyNullableValue<out K, V : Any>

KeyNullableValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

data class KeyNullableValue<out K, V : Any>

KeyNullableValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

data class KeyNullableValue<out K, V : Any>

KeyNullableValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

data class KeyValue<out K, V : Any>

KeyValue(key: K, valueAssertionCreatorOrNull: (Expect<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Expect<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Expect<V>.() -> Unit)?

data class KeyValue<out K, V : Any>

KeyValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

data class KeyValue<out K, V : Any>

KeyValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

data class KeyValue<out K, V : Any>

KeyValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

class KeyValues<out K, V : Any> : VarArgHelper<KeyWithValueCreator<K, V>>

val expected: KeyWithValueCreator<K, V>
val otherExpected: Array<out KeyWithValueCreator<K, V>>

data class KeyWithCreator<out K, V>

val assertionCreator: Expect<V>.() -> Unit
val key: K

data class KeyWithValueCreator<out K, V : Any>

val key: K
fun toPair(): Pair<K, (Expect<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Expect<V>.() -> Unit)?

interface Keyword
interface Keyword
class KindStepImpl<T> : SubjectChangerBuilder.KindStep<T>

KindStepImpl(container: AssertionContainer<T>)
val container: AssertionContainer<T>
fun reportBuilder(): SubjectChangerBuilder.DescriptionRepresentationStep<T>

kotlin.Function0

fun <T> (() -> T).evalOnce(): () -> T

kotlin.reflect.KClass

expect fun <T : Any> KClass<T>.cast(any: Any?): T
expect val KClass<*>.fullName: String
expect fun <T : Any> KClass<out T>.fullName(obj: T): String

kotlin.String

expect fun String.format(locale: Locale, arg: Any, vararg otherArgs: Any): String
expect fun String.format(arg: Any, vararg otherArgs: Any): String

kotlin.Throwable

expect val Throwable.stackBacktrace: List<String>

class LazyRepresentation

LazyRepresentation(provider: () -> Any?)
fun eval(): Any?

class LazyThreadUnsafeAssertionGroup : AssertionGroup

LazyThreadUnsafeAssertionGroup(assertionCreator: () -> AssertionGroup)
val assertions: List<Assertion>
val description: Translatable
fun holds(): Boolean
val representation: Any
val type: AssertionGroupType

data class Left<L> : Either<L, Nothing>

Left(l: L)
val l: L

interface ListAssertionGroupType : AssertionGroupType
interface ListAssertions

abstract fun <E, T : List<E>> get(container: AssertionContainer<T>, index: Int): FeatureExtractorBuilder.ExecutionStep<T, E>

interface ListAssertions

abstract fun <E, T : List<E>> get(expect: Expect<T>, index: Int): ExtractedFeaturePostStep<T, E>
abstract fun <T : Any> get(plant: AssertionPlant<List<T>>, index: Int): AssertionPlant<T>
abstract fun <T : Any> get(plant: AssertionPlant<List<T>>, index: Int, assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
abstract fun <T> getNullable(plant: AssertionPlant<List<T>>, index: Int): AssertionPlantNullable<T>
abstract fun <T> getNullable(plant: AssertionPlant<List<T>>, index: Int, assertionCreator: AssertionPlantNullable<T>.() -> Unit): Assertion

object ListAssertionsBuilder : ListAssertions

inline fun <E, T : List<E>> get(expect: Expect<T>, index: Int): ExtractedFeaturePostStep<T, E>
fun <T : Any> get(plant: AssertionPlant<List<T>>, index: Int): AssertionPlant<T>
inline fun <T : Any> get(plant: AssertionPlant<List<T>>, index: Int, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
fun <T> getNullable(plant: AssertionPlant<List<T>>, index: Int): AssertionPlantNullable<T>
inline fun <T> getNullable(plant: AssertionPlant<List<T>>, index: Int, noinline assertionCreator: AssertionPlantNullable<T>.() -> Unit): Assertion

interface ListGetNullableOption<E, T : List<E>>

abstract infix fun assertIt(assertionCreator: AssertionPlantNullable<E>.() -> Unit): Assert<T>
fun <E, T : List<E>> create(plant: Assert<T>, index: Int): ListGetNullableOption<E, T>
abstract val index: Int
abstract val plant: Assert<T>

interface ListGetOption<E : Any, T : List<E>>

abstract infix fun assertIt(assertionCreator: Assert<E>.() -> Unit): Assert<T>
fun <E : Any, T : List<E>> create(plant: Assert<T>, index: Int): ListGetOption<E, T>
abstract val index: Int
abstract val plant: Assert<T>

interface LocalDateAssertions

abstract fun day(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>
abstract fun dayOfWeek(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, DayOfWeek>
abstract fun month(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>
abstract fun year(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>

interface LocalDateAssertions

abstract fun <T : LocalDate> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : LocalDate> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
abstract fun <T : LocalDate> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : LocalDate> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

object LocalDateAssertionsBuilder : LocalDateAssertions

inline fun <T : LocalDate> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : LocalDate> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
inline fun <T : LocalDate> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : LocalDate> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

interface LocalDateTimeAssertions

abstract fun day(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>
abstract fun dayOfWeek(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, DayOfWeek>
abstract fun month(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>
abstract fun year(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>

interface LocalDateTimeAssertions

abstract fun <T : LocalDateTime> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : LocalDateTime> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
abstract fun <T : LocalDateTime> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : LocalDateTime> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

object LocalDateTimeAssertionsBuilder : LocalDateTimeAssertions

inline fun <T : LocalDateTime> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : LocalDateTime> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
inline fun <T : LocalDateTime> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : LocalDateTime> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

data class Locale

Locale(language: String, country: String)
Locale(language: String)
Locale(language: String, script: String?, country: String?, variant: String?)
val country: String?
val language: String
val script: String?
fun toString(): String
val variant: String?

interface LocaleOrderDecider

abstract fun determineOrder(primaryLocale: Locale, fallbackLocales: List<Locale>): Sequence<Locale>

interface LocaleOrderDeciderOption

fun create(translationSupplier: TranslationSupplier): LocaleOrderDeciderOption
abstract val translationSupplier: TranslationSupplier
abstract fun withDefaultLocaleOrderDecider(): TranslatorOption
abstract fun withLocaleOrderDecider(localeOrderDecider: LocaleOrderDecider): TranslatorOption

interface MapAssertions

abstract fun <K, V, T : Map<out K, V>> contains(expect: Expect<T>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V> contains(plant: AssertionPlant<Map<out K, V>>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K> containsKey(subjectProvider: SubjectProvider<Map<out K, *>>, key: K): Assertion
abstract fun <K, V : Any, T : Map<out K, V?>> containsKeyWithValueAssertions(expect: Expect<T>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any> containsKeyWithValueAssertions(plant: AssertionPlant<Map<out K, V?>>, keyValues: List<Pair<K, (Assert<V>.() -> Unit)?>>): Assertion
abstract fun <K> containsNotKey(subjectProvider: SubjectProvider<Map<out K, *>>, key: K): Assertion
abstract fun <K, V, T : Map<out K, V>> getExisting(expect: Expect<T>, key: K): ExtractedFeaturePostStep<T, V>
abstract fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlant<V>
abstract fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
abstract fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlantNullable<V>
abstract fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun hasSize(plant: AssertionPlant<Map<*, *>>, size: Int): Assertion
abstract fun isEmpty(subjectProvider: SubjectProvider<Map<*, *>>): Assertion
abstract fun isNotEmpty(subjectProvider: SubjectProvider<Map<*, *>>): Assertion
abstract fun <K> keys(plant: AssertionPlant<Map<out K, *>>, assertionCreator: AssertionPlant<Set<K>>.() -> Unit): Assertion
abstract fun <T : Map<*, *>> size(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <V> values(plant: AssertionPlant<Map<*, V>>, assertionCreator: AssertionPlant<Collection<V>>.() -> Unit): Assertion

object MapAssertionsBuilder : MapAssertions

inline fun <K, V, T : Map<out K, V>> contains(expect: Expect<T>, keyValuePairs: List<Pair<K, V>>): Assertion
inline fun <K, V> contains(plant: AssertionPlant<Map<out K, V>>, keyValuePairs: List<Pair<K, V>>): Assertion
inline fun <K> containsKey(subjectProvider: SubjectProvider<Map<out K, *>>, key: K): Assertion
inline fun <K, V : Any, T : Map<out K, V?>> containsKeyWithValueAssertions(expect: Expect<T>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
inline fun <K, V : Any> containsKeyWithValueAssertions(plant: AssertionPlant<Map<out K, V?>>, keyValues: List<Pair<K, (Assert<V>.() -> Unit)?>>): Assertion
inline fun <K> containsNotKey(subjectProvider: SubjectProvider<Map<out K, *>>, key: K): Assertion
inline val entry: MapEntryAssertionsBuilder
inline fun <K, V, T : Map<out K, V>> getExisting(expect: Expect<T>, key: K): ExtractedFeaturePostStep<T, V>
inline fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlant<V>
inline fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K, noinline assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
inline fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlantNullable<V>
inline fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
inline fun hasSize(plant: AssertionPlant<Map<*, *>>, size: Int): Assertion
inline fun isEmpty(subjectProvider: SubjectProvider<Map<*, *>>): Assertion
inline fun isNotEmpty(subjectProvider: SubjectProvider<Map<*, *>>): Assertion
inline fun <K> keys(plant: AssertionPlant<Map<out K, *>>, noinline assertionCreator: AssertionPlant<Set<K>>.() -> Unit): Assertion
inline fun <T : Map<*, *>> size(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <V> values(plant: AssertionPlant<Map<*, V>>, noinline assertionCreator: AssertionPlant<Collection<V>>.() -> Unit): Assertion

interface MapEntryAssertions

abstract fun <K, V, T : Entry<K, V>> isKeyValue(container: AssertionContainer<T>, key: K, value: V): Assertion
abstract fun <K, T : Entry<K, *>> key(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
abstract fun <V, T : Entry<*, V>> value(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>

interface MapEntryAssertions

abstract fun <K, V, T : Entry<K, V>> isKeyValue(expect: Expect<T>, key: K, value: V): Assertion
abstract fun <K : Any, V : Any> isKeyValue(plant: AssertionPlant<Entry<K, V>>, key: K, value: V): Assertion
abstract fun <K, T : Entry<K, *>> key(expect: Expect<T>): ExtractedFeaturePostStep<T, K>
abstract fun <K : Any> key(plant: AssertionPlant<Entry<K, *>>, assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
abstract fun <K> nullableKey(plant: AssertionPlant<Entry<K, *>>, assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
abstract fun <V> nullableValue(plant: AssertionPlant<Entry<*, V>>, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun <V, T : Entry<*, V>> value(expect: Expect<T>): ExtractedFeaturePostStep<T, V>
abstract fun <V : Any> value(plant: AssertionPlant<Entry<*, V>>, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion

object MapEntryAssertionsBuilder : MapEntryAssertions

inline fun <K, V, T : Entry<K, V>> isKeyValue(expect: Expect<T>, key: K, value: V): Assertion
inline fun <K : Any, V : Any> isKeyValue(plant: AssertionPlant<Entry<K, V>>, key: K, value: V): Assertion
inline fun <K, T : Entry<K, *>> key(expect: Expect<T>): ExtractedFeaturePostStep<T, K>
inline fun <K : Any> key(plant: AssertionPlant<Entry<K, *>>, noinline assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
inline fun <K> nullableKey(plant: AssertionPlant<Entry<K, *>>, noinline assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
inline fun <V> nullableValue(plant: AssertionPlant<Entry<*, V>>, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
inline fun <V, T : Entry<*, V>> value(expect: Expect<T>): ExtractedFeaturePostStep<T, V>
inline fun <V : Any> value(plant: AssertionPlant<Entry<*, V>>, noinline assertionCreator: AssertionPlant<V>.() -> Unit): Assertion

interface MapGetNullableOption<K, V, T : Map<out K, V>>

abstract infix fun assertIt(assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assert<T>
fun <K, V, T : Map<out K, V>> create(plant: Assert<T>, key: K): MapGetNullableOption<K, V, T>
abstract val key: K
abstract val plant: Assert<T>

interface MapGetOption<K, V : Any, T : Map<out K, V>>

abstract infix fun assertIt(assertionCreator: Assert<V>.() -> Unit): Assert<T>
fun <K, V : Any, T : Map<out K, V>> create(plant: Assert<T>, key: K): MapGetOption<K, V, T>
abstract val key: K
abstract val plant: Assert<T>

typealias MapLike = Any
interface MapLikeAssertions

abstract fun <T, K, V> builderContainsInMapLike(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>): MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>
abstract fun <K, T> containsKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
abstract fun <K, T> containsNotKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
abstract fun <K, V, T> getExisting(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, key: K): FeatureExtractorBuilder.ExecutionStep<T, V>

interface MapLikeContains

interface Checker : Contains.Checker
interface Creator<T, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<K, V, T, out S : MapLikeContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<K, V, T, out S : MapLikeContains.SearchBehaviour> : MapLikeContains.EntryPointStep<K, V, T, S>, MapLikeContains.EntryPointStepLogic<K, V, T, S>
interface EntryPointStepLogic<K, V, T, out S : MapLikeContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>

abstract val converter: (T) -> Map<out K, V>
open fun <S2 : MapLikeContains.SearchBehaviour> withSearchBehaviour(searchBehaviour: S2): MapLikeContains.EntryPointStep<K, V, T, S2>

interface SearchBehaviour : Contains.SearchBehaviour

interface MapLikeContainsAssertions

abstract fun <K, V, T> keyValuePairsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V, T> keyValuePairsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V, T> keyValuePairsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderSearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion

interface MapLikeToIterablePairTransformer

abstract fun supportedTypes(): List<String>
abstract fun <K, V> unsafeTransform(mapLike: MapLike): List<Pair<K, V>>

sealed class MaybeSubject<out T>

object Absent : MaybeSubject<Nothing>

fun get(): Nothing

abstract fun get(): T
operator fun <T : Any> invoke(subject: T?): MaybeSubject<T>
data class Present<T> : MaybeSubject<T>

Present(subject: T)
fun get(): T
val subject: T

data class MetaFeature<T>

MetaFeature(description: String, representation: Any?, maybeSubject: Option<T>)
MetaFeature(description: String, subject: T)
MetaFeature(description: Translatable, representation: Any?, maybeSubject: Option<T>)
val description: Translatable
val maybeSubject: Option<T>
val representation: Any?

object MetaFeatureBuilder

fun <T, R> create(expect: Expect<T>, description: String, provider: (T) -> R): MetaFeature<R>
fun <T, R> create(expect: Expect<T>, description: Translatable, provider: (T) -> R): MetaFeature<R>
fun <T, R> createSubjectBased(expect: Expect<T>, provider: (T) -> MetaFeature<R>): MetaFeature<R>
fun <R> f0(expect: Expect<*>, f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f1(expect: Expect<*>, f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f2(expect: Expect<*>, f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f3(expect: Expect<*>, f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f4(expect: Expect<*>, f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f5(expect: Expect<*>, f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <TProperty> property(property: KProperty0<TProperty>): MetaFeature<TProperty>

class MetaFeatureOption<T>

MetaFeatureOption(expect: Expect<T>)
fun <R> f(property: KProperty0<R>): MetaFeature<R>
fun <R> f(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> f0(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f1(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f2(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f3(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f4(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f5(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> p(property: KProperty0<R>): MetaFeature<R>

data class MetaFeatureOptionWithCreator<T, R>

val assertionCreator: Expect<R>.() -> Unit
val provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>

interface MethodCallFormatter

abstract fun format(methodName: String, arguments: Array<out Any?>): () -> String
abstract fun formatArgument(argument: Any?): String
abstract fun formatCall(methodName: String, arguments: Array<out Any?>): String

interface MultipleAdjustersOption : AtriumErrorAdjusterCommonOption<Unit>

abstract val adjusters: List<AtriumErrorAdjuster>
fun create(): MultipleAdjustersOption
abstract fun withAtriumErrorAdjuster(adjuster: AtriumErrorAdjuster): Unit
abstract fun withRemoveAtriumFromAtriumErrorAdjuster(): Unit
abstract fun withRemoveRunnerAtriumErrorAdjuster(): Unit

@DslMarker annotation class MultipleAdjustersOptionMarker

MultipleAdjustersOptionMarker()

interface NewFeatureAssertions

abstract fun <T, R> genericFeature(expect: Expect<T>, metaFeature: MetaFeature<R>): ExtractedFeaturePostStep<T, R>

object NewFeatureAssertionsBuilder : NewFeatureAssertions

inline fun <T> extractor(originalAssertionContainer: Expect<T>): FeatureExtractorBuilder.DescriptionStep<T>
fun <T, R> f0(expect: Expect<T>, f: KFunction1<T, R>): ExtractedFeaturePostStep<T, R>
fun <T, A1, R> f1(expect: Expect<T>, f: KFunction2<T, A1, R>, a1: A1): ExtractedFeaturePostStep<T, R>
fun <T, A1, A2, R> f2(expect: Expect<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): ExtractedFeaturePostStep<T, R>
fun <T, A1, A2, A3, R> f3(expect: Expect<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): ExtractedFeaturePostStep<T, R>
fun <T, A1, A2, A3, A4, R> f4(expect: Expect<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): ExtractedFeaturePostStep<T, R>
fun <T, A1, A2, A3, A4, A5, R> f5(expect: Expect<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): ExtractedFeaturePostStep<T, R>
inline fun <T, R> genericFeature(expect: Expect<T>, metaFeature: MetaFeature<R>): ExtractedFeaturePostStep<T, R>
fun <T, R> genericSubjectBasedFeature(expect: Expect<T>, provider: (T) -> MetaFeature<R>): ExtractedFeaturePostStep<T, R>
fun <T, R> manualFeature(expect: Expect<T>, description: String, provider: T.() -> R): ExtractedFeaturePostStep<T, R>
fun <T, R> manualFeature(expect: Expect<T>, description: Translatable, provider: T.() -> R): ExtractedFeaturePostStep<T, R>
inline val meta: MetaFeatureBuilder
fun <T, TProperty> property(expect: Expect<T>, property: KProperty1<in T, TProperty>): ExtractedFeaturePostStep<T, TProperty>

object next : Keyword
class NoAdjustingReporterFactory : ReporterFactory

NoAdjustingReporterFactory()
fun create(): Reporter
val id: String
const val ID: String

object noDuplicates : Keyword
object None : Option<Nothing>
interface NonThrowingAssertionCollectorForExplanation : AssertionCollectorForExplanation
class NoOpCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStepInternal<E, T, S>

NoOpCheckerStep(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, S>)
val checkers: List<IterableLikeContains.Checker>
val entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, S>

interface NoOpSearchBehaviour : CharSequenceContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NoOpSearchBehaviour : IterableLikeContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NoOpSearchBehaviour : MapLikeContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NoOpSearchBehaviour : CharSequenceContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NoOpSearchBehaviour : IterableContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

class NoOpSearchBehaviourImpl : NoOpSearchBehaviour

NoOpSearchBehaviourImpl()

class NoOpSearchBehaviourImpl : NoOpSearchBehaviour

NoOpSearchBehaviourImpl()

class NoOpSearchBehaviourImpl : NoOpSearchBehaviour

NoOpSearchBehaviourImpl()

interface NotChecker : CharSequenceContains.Checker
interface NotChecker : NotChecker, CharSequenceContains.Checker
interface NotChecker : NotChecker, IterableLikeContains.Checker
interface NotChecker : NotChecker, MapLikeContains.Checker
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
abstract class NotCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>

NotCheckerOptionBase(containsBuilder: CharSequenceContains.Builder<T, S>)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>

abstract class NotCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>

NotCheckerOptionBase(containsBuilder: IterableContains.Builder<E, T, S>)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContains.Builder<E, T, S>

open class NotCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>

NotCheckerOptionImpl(containsBuilder: CharSequenceContains.Builder<T, S>)

open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>

NotCheckerOptionImpl(containsBuilder: IterableContains.Builder<E, T, S>)

open class NotCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>

NotCheckerOptionImpl(containsBuilder: CharSequenceContains.Builder<T, S>)

open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>

NotCheckerOptionImpl(containsBuilder: IterableContains.Builder<E, T, S>)

interface NotCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
interface NotCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class NotOrAtMostCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

NotOrAtMostCheckerOptionBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class NotOrAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

NotOrAtMostCheckerOptionBase(times: Int, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface NotOrAtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
interface NotOrAtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
interface NotSearchBehaviour : NoOpSearchBehaviour
interface NotSearchBehaviour : InAnyOrderSearchBehaviour
interface NotSearchBehaviour : NoOpSearchBehaviour
interface NotSearchBehaviour : InAnyOrderSearchBehaviour
class NotSearchBehaviourImpl : NotSearchBehaviour

NotSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class NotSearchBehaviourImpl : NotSearchBehaviour

NotSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class NullableEintraege<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEintraege(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

class NullableEintrag<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEintrag(assertionCreator: (Assert<T>.() -> Unit)?)
val assertionCreator: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

class NullableEntries<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEntries(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

class NullableEntries<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEntries(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

class NullableEntry<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEntry(assertionCreator: (Assert<T>.() -> Unit)?)
val assertionCreator: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

class NullableEntry<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEntry(assertionCreator: (Assert<T>.() -> Unit)?)
val assertionCreator: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

data class NullableValue<T> : GroupWithNullableEntries<T>

NullableValue(expected: T)
val expected: T
fun toList(): List<T>

data class NullableValue<T> : GroupWithNullableEntries<T>

NullableValue(expected: T)
val expected: T
fun toList(): List<T>

class NullableValues<T> : GroupWithNullableEntries<T>

NullableValues(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): List<T>

class NullableValues<T> : GroupWithNullableEntries<T>

NullableValues(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

data class NullableWert<T> : GroupWithNullableEntries<T>

NullableWert(expected: T)
val expected: T
fun toList(): List<T>

class NullableWerte<T> : GroupWithNullableEntries<T>

NullableWerte(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): List<T>

object o : Keyword
interface ObjectFormatter

abstract fun format(value: Any?): String

interface ObjectFormatterOption

fun create(translator: Translator): ObjectFormatterOption
abstract val translator: Translator
abstract fun withDetailedObjectFormatter(): AssertionFormatterControllerOption
abstract fun withObjectFormatter(factory: (Translator) -> ObjectFormatter): AssertionFormatterControllerOption

class Objects<out T>

Objects(values: Values<T>)
Objects(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>

object only : Keyword
object only
object only : Keyword
sealed class Option<out T>

inline fun filter(predicate: (T) -> Boolean): Option<T>
inline fun <R> flatMap(f: (T) -> Option<R>): Option<R>
inline fun <R> fold(default: () -> R, f: (T) -> R): R
fun isDefined(): Boolean
inline fun <R> map(f: (T) -> R): Option<R>
inline fun <T> someIf(predicate: Boolean, provider: () -> T): Option<T>

interface OptionalAssertions

abstract fun <T : Optional<*>> isEmpty(container: AssertionContainer<T>): Assertion
abstract fun <E, T : Optional<E>> isPresent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, E>

interface OptionalAssertions

abstract fun <T : Optional<*>> isEmpty(expect: Expect<T>): Assertion
abstract fun <E, T : Optional<E>> isPresent(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

object OptionalAssertionsBuilder : OptionalAssertions

inline fun <T : Optional<*>> isEmpty(expect: Expect<T>): Assertion
inline fun <E, T : Optional<E>> isPresent(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

class OptionsStepImpl<T, R> : FeatureExtractorBuilder.OptionsStep<T, R>

OptionsStepImpl(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>)
val featureExtraction: (T) -> Option<R>
val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
fun withOptions(expectOptions: FeatureExpectOptions<R>): FeatureExtractorBuilder.FinalStep<T, R>
fun withoutOptions(): FeatureExtractorBuilder.FinalStep<T, R>

object order : Keyword
class Order<out T, out G : Group<T>>

val firstGroup: G
val otherExpectedGroups: Array<out G>
val secondGroup: G
fun toList(): List<List<T>>

object order
class Order<out T, out G : Group<T>>

Order(firstGroup: G, secondGroup: G, vararg otherExpectedGroups: G)
val firstGroup: G
vararg val otherExpectedGroups: Array<out G>
val secondGroup: G

object order : Keyword
interface PairAssertions

abstract fun <K, T : Pair<K, *>> first(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
abstract fun <V, T : Pair<*, V>> second(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>

interface PairAssertions

abstract fun <K, T : Pair<K, *>> first(expect: Expect<T>): ExtractedFeaturePostStep<T, K>
abstract fun <K : Any> first(plant: AssertionPlant<Pair<K, *>>, assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
abstract fun <K> nullableFirst(plant: AssertionPlant<Pair<K, *>>, assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
abstract fun <V> nullableSecond(plant: AssertionPlant<Pair<*, V>>, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun <V, T : Pair<*, V>> second(expect: Expect<T>): ExtractedFeaturePostStep<T, V>
abstract fun <V : Any> second(plant: AssertionPlant<Pair<*, V>>, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion

object PairAssertionsBuilder : PairAssertions

inline fun <K, T : Pair<K, *>> first(expect: Expect<T>): ExtractedFeaturePostStep<T, K>
inline fun <K : Any> first(plant: AssertionPlant<Pair<K, *>>, noinline assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
inline fun <K> nullableFirst(plant: AssertionPlant<Pair<K, *>>, noinline assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
inline fun <V> nullableSecond(plant: AssertionPlant<Pair<*, V>>, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
inline fun <V, T : Pair<*, V>> second(expect: Expect<T>): ExtractedFeaturePostStep<T, V>
inline fun <V : Any> second(plant: AssertionPlant<Pair<*, V>>, noinline assertionCreator: AssertionPlant<V>.() -> Unit): Assertion

class Pairs<out K, out V> : VarArgHelper<Pair<K, V>>

val expected: Pair<K, V>
val otherExpected: Array<out Pair<K, V>>

class Pairs<out K, out V> : VarArgHelper<Pair<K, V>>

Pairs(expected: Pair<K, V>, vararg otherExpected: Pair<K, V>)
val expected: Pair<K, V>
vararg val otherExpected: Array<out Pair<K, V>>

interface PartiallyFixedClaimGroup

interface FinalStep : BasicAssertionGroupFinalStep

fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>, holds: Boolean): PartiallyFixedClaimGroup.FinalStep
abstract val preTransformationHolds: Boolean

interface GroupTypeOption : FixedClaimLikeGroup.GroupTypeOption<PartiallyFixedClaimGroup.FinalStep>

fun create(): PartiallyFixedClaimGroup.GroupTypeOption

interface HoldsOption<T : AssertionGroupType> : FixedClaimLikeGroup.HoldsOption<T, PartiallyFixedClaimGroup.FinalStep>

fun <T : AssertionGroupType> create(groupType: T): PartiallyFixedClaimGroup.HoldsOption<T>

interface PathAssertions

abstract fun <T : Path> endsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> endsWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> exists(container: AssertionContainer<T>, linkOption: LinkOption? = null): Assertion
abstract fun <T : Path> existsNot(container: AssertionContainer<T>, linkOption: LinkOption? = null): Assertion
abstract fun <T : Path> extension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> fileName(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> fileNameWithoutExtension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> hasDirectoryEntry(container: AssertionContainer<T>, entries: List<String>): Assertion
abstract fun <T : Path> hasSameBinaryContentAs(container: AssertionContainer<T>, targetPath: Path): Assertion
abstract fun <T : Path> hasSameTextualContentAs(container: AssertionContainer<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
abstract fun <T : Path> isAbsolute(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isDirectory(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isExecutable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isReadable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isRegularFile(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isRelative(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isWritable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> parent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, Path>
abstract fun <T : Path> resolve(container: AssertionContainer<T>, other: String): FeatureExtractorBuilder.ExecutionStep<T, Path>
abstract fun <T : Path> startsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> startsWith(container: AssertionContainer<T>, expected: Path): Assertion

interface PathAssertions

abstract fun <T : Path> endsNotWith(expect: Expect<T>, expected: Path): Assertion
abstract fun <T : Path> endsWith(expect: Expect<T>, expected: Path): Assertion
abstract fun <T : Path> exists(expect: Expect<T>): Assertion
abstract fun <T : Path> existsNot(expect: Expect<T>): Assertion
abstract fun <T : Path> extension(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
abstract fun <T : Path> fileName(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
abstract fun <T : Path> fileNameWithoutExtension(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
abstract fun <T : Path> hasSameBinaryContentAs(expect: Expect<T>, targetPath: Path): Assertion
abstract fun <T : Path> hasSameTextualContentAs(expect: Expect<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
abstract fun <T : Path> isDirectory(expect: Expect<T>): Assertion
abstract fun <T : Path> isReadable(expect: Expect<T>): Assertion
abstract fun <T : Path> isRegularFile(expect: Expect<T>): Assertion
abstract fun <T : Path> isWritable(expect: Expect<T>): Assertion
abstract fun <T : Path> parent(expect: Expect<T>): ExtractedFeaturePostStep<T, Path>
abstract fun <T : Path> resolve(expect: Expect<T>, other: String): ExtractedFeaturePostStep<T, Path>
abstract fun <T : Path> startsNotWith(expect: Expect<T>, expected: Path): Assertion
abstract fun <T : Path> startsWith(expect: Expect<T>, expected: Path): Assertion

object PathAssertionsBuilder : PathAssertions

inline fun <T : Path> endsNotWith(expect: Expect<T>, expected: Path): Assertion
inline fun <T : Path> endsWith(expect: Expect<T>, expected: Path): Assertion
inline fun <T : Path> exists(expect: Expect<T>): Assertion
inline fun <T : Path> existsNot(expect: Expect<T>): Assertion
inline fun <T : Path> extension(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
inline fun <T : Path> fileName(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
inline fun <T : Path> fileNameWithoutExtension(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
inline fun <T : Path> hasSameBinaryContentAs(expect: Expect<T>, targetPath: Path): Assertion
inline fun <T : Path> hasSameTextualContentAs(expect: Expect<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
inline fun <T : Path> isDirectory(expect: Expect<T>): Assertion
inline fun <T : Path> isReadable(expect: Expect<T>): Assertion
inline fun <T : Path> isRegularFile(expect: Expect<T>): Assertion
inline fun <T : Path> isWritable(expect: Expect<T>): Assertion
inline fun <T : Path> parent(expect: Expect<T>): ExtractedFeaturePostStep<T, Path>
inline fun <T : Path> resolve(expect: Expect<T>, other: String): ExtractedFeaturePostStep<T, Path>
inline fun <T : Path> startsNotWith(expect: Expect<T>, expected: Path): Assertion
inline fun <T : Path> startsWith(expect: Expect<T>, expected: Path): Assertion

data class PathWithCreator<E>

val assertionCreator: Expect<E>.() -> Unit
val path: String

data class PathWithEncoding

val path: Path
val sourceCharset: Charset
val targetCharset: Charset

class PlantHasNoSubjectException : RuntimeException

PlantHasNoSubjectException()
PlantHasNoSubjectException(message: String)

class PleaseUseReplacementException : Exception

PleaseUseReplacementException(reason: String)

abstract class PostFinalStep<T, R, E : Expect<R>>

PostFinalStep(expect: Expect<T>, action: Expect<T>.() -> E, actionAndApply: Expect<T>.(Expect<R>.() -> Unit) -> Expect<R>)
protected val action: Expect<T>.() -> E
protected val actionAndApply: Expect<T>.(Expect<R>.() -> Unit) -> Expect<R>
fun addToFeature(assertionCreator: Expect<R>.() -> Unit): Expect<R>
fun addToInitial(assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun collect(assertionCreator: Expect<R>.() -> Unit): Assertion
protected val expect: Expect<T>
fun getExpectOfFeature(): E

class PrefixFailingSummaryAssertion : BulletPointIdentifier
class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier
class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier
object present : Keyword
data class PresentWithCreator<E>

val assertionCreator: Expect<E>.() -> Unit

interface RawString

fun create(string: String): RawString
fun create(translatable: Translatable): RawString
val EMPTY: StringBasedRawString
val NULL: StringBasedRawString

object readable : Keyword
class RegexPatterns : VarArgHelper<String>

val expected: String
val otherExpected: Array<out String>

class RegexPatterns

RegexPatterns(pattern: String, vararg otherPatterns: String)
vararg val otherPatterns: Array<out String>
val pattern: String
fun toList(): List<String>

class RegexPatterns : VarArgHelper<String>

RegexPatterns(pattern: String, vararg otherPatterns: String)
val expected: String
val otherExpected: Array<out String>

class RegexSearcher : CharSequenceContains.Searcher<NoOpSearchBehaviour, Regex>

RegexSearcher()
fun search(searchIn: CharSequence, searchFor: Regex): Int

object relative : Keyword
interface Reporter

abstract val atriumErrorAdjuster: AtriumErrorAdjuster
abstract fun format(assertion: Assertion, sb: StringBuilder): Unit

class ReporterBuilder

ReporterBuilder(assertionFormatterFacade: AssertionFormatterFacade)
class AssertionFormatterChosenOptions

AssertionFormatterChosenOptions(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator)
val assertionFormatterFacade: AssertionFormatterFacade
val objectFormatter: ObjectFormatter
val translator: Translator

class AssertionFormatterControllerOptions

AssertionFormatterControllerOptions(objectFormatter: ObjectFormatter, translator: Translator)
fun withAssertionFormatterController(assertionFormatterController: AssertionFormatterController): ReporterBuilder.AssertionFormatterFacadeOptions
fun withDefaultAssertionFormatterController(): ReporterBuilder.AssertionFormatterFacadeOptions

class AssertionFormatterFacadeOptions

AssertionFormatterFacadeOptions(assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator)
fun withAssertionFormatterFacade(factory: (AssertionFormatterController) -> AssertionFormatterFacade): ReporterBuilder.AssertionPairFormatterOptions
fun withDefaultAssertionFormatterFacade(): ReporterBuilder.AssertionPairFormatterOptions

class AssertionPairFormatterOptions

AssertionPairFormatterOptions(options: ReporterBuilder.AssertionFormatterChosenOptions)
fun withSameLineTextAssertionFormatter(vararg bulletPoints: Pair<Class<out BulletPointIdentifier>, String>): ReporterBuilder
fun withTextAssertionPairFormatter(factory: (ObjectFormatter, Translator) -> AssertionPairFormatter): ReporterBuilder.TextAssertionFormatterOptions
fun withTextSameLineAssertionPairFormatter(): ReporterBuilder.TextAssertionFormatterOptions

fun buildCustomReporter(factory: (AssertionFormatterFacade) -> Reporter): Reporter
fun buildOnlyFailureReporter(): Reporter
class LocaleOrderDeciderOptions

LocaleOrderDeciderOptions(translationSupplier: TranslationSupplier)
fun withDefaultLocaleOrderDecider(): ReporterBuilder.TranslatorOptions
fun withLocaleOrderDecider(localeOrderDecider: LocaleOrderDecider): ReporterBuilder.TranslatorOptions

class ObjectFormatterOptions

ObjectFormatterOptions(translator: Translator)
fun withDetailedObjectFormatter(): ReporterBuilder.AssertionFormatterControllerOptions
fun withObjectFormatter(factory: (Translator) -> ObjectFormatter): ReporterBuilder.AssertionFormatterControllerOptions

class TextAssertionFormatterOptions

TextAssertionFormatterOptions(options: ReporterBuilder.AssertionFormatterChosenOptions, assertionPairFormatter: AssertionPairFormatter)
fun withDefaultTextCapabilities(vararg bulletPoints: Pair<Class<out BulletPointIdentifier>, String>): ReporterBuilder
fun withTextAssertionFormatter(factory: (ReporterBuilder.AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter, vararg otherFactories: (ReporterBuilder.AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter): ReporterBuilder

class TranslatorOptions

TranslatorOptions(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider)
fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ReporterBuilder.ObjectFormatterOptions
fun withTranslator(factory: (TranslationSupplier, LocaleOrderDecider) -> Translator): ReporterBuilder.ObjectFormatterOptions

fun withDefaultTranslationSupplier(): ReporterBuilder.LocaleOrderDeciderOptions
fun withoutTranslations(primaryLocale: Locale = java.util.Locale.getDefault()): ReporterBuilder.ObjectFormatterOptions
fun withTranslationSupplier(translationSupplier: TranslationSupplier): ReporterBuilder.LocaleOrderDeciderOptions
fun withTranslator(translator: Translator): ReporterBuilder.ObjectFormatterOptions

expect interface ReporterBuilder : ReporterBuilderCommon

fun create(): ReporterBuilder
open fun withoutTranslations(primaryLocale: Locale = java.util.Locale.getDefault()): ObjectFormatterOption

interface ReporterBuilderCommon

abstract fun withDefaultTranslationSupplier(): LocaleOrderDeciderOption
abstract fun withoutTranslations(primaryLocale: Locale): ObjectFormatterOption
open fun withoutTranslationsUseDefaultLocale(): ObjectFormatterOption
abstract fun withTranslationSupplier(translationSupplier: TranslationSupplier): LocaleOrderDeciderOption
abstract fun withTranslator(translator: Translator): ObjectFormatterOption

interface ReporterBuilderFinalStep

abstract fun build(): Reporter
fun create(factory: () -> Reporter): ReporterBuilderFinalStep

interface ReporterFactory

const val ATRIUM_PROPERTY_KEY: String
abstract fun create(): Reporter
abstract val id: String
fun specifyFactory(reporterFactoryId: String): Unit
fun specifyFactoryIfNotYetSet(reporterFactoryId: String): Unit

interface ReporterOption

abstract val assertionFormatterFacade: AssertionFormatterFacade
abstract val atriumErrorAdjuster: AtriumErrorAdjuster
fun create(assertionFormatterFacade: AssertionFormatterFacade, atriumErrorAdjuster: AtriumErrorAdjuster): ReporterOption
abstract fun withCustomReporter(factory: (AssertionFormatterFacade, AtriumErrorAdjuster) -> Reporter): ReporterBuilderFinalStep
abstract fun withOnlyFailureReporter(): ReporterBuilderFinalStep

interface ReportingAssertionContainer<T> : RootExpect<T>

abstract val assertionChecker: AssertionChecker
interface AssertionCheckerDecorator<T>

abstract val assertionChecker: AssertionChecker
abstract val assertionVerb: Translatable
abstract fun check(assertions: List<Assertion>): Unit
fun <T> create(assertionVerb: Translatable, maybeSubject: Option<T>, representation: Any?, assertionChecker: AssertionChecker): ReportingAssertionContainer.AssertionCheckerDecorator<T>
abstract val maybeSubject: Option<T>
abstract val representation: Any?

interface ReportingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseReportingAssertionPlant<T, AssertionPlant<T>>
interface ReportingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseReportingAssertionPlant<T, AssertionPlantNullable<T>>
interface RepresentationOnly

interface FinalStep : AssertionBuilderFinalStep<RepresentationOnlyAssertion>

fun create(test: () -> Boolean, representation: Any?): RepresentationOnly.FinalStep
abstract val representation: Any?
abstract val test: () -> Boolean

interface HoldsStep : HoldsStep<RepresentationOnly.RepresentationStep>

fun create(): RepresentationOnly.HoldsStep

interface RepresentationStep

fun create(test: () -> Boolean): RepresentationOnly.RepresentationStep
abstract val test: () -> Boolean
abstract fun withRepresentation(representation: Any?): RepresentationOnly.FinalStep

interface RepresentationOnlyAssertion : Assertion

abstract val representation: Any?

interface ResultAssertions

abstract fun <TExpected : Throwable> isFailureOfType(container: AssertionContainer<out Result<*>>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected>
abstract fun <E, T : Result<E>> isSuccess(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, E>

interface ResultAssertions

abstract fun <TExpected : Throwable> isFailure(expect: Expect<out Result<*>>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<Throwable?, TExpected>
abstract fun <E, T : Result<E>> isSuccess(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

object ResultAssertionsBuilder : ResultAssertions

fun <TExpected : Throwable> isFailure(expect: Expect<out Result<*>>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<Throwable?, TExpected>
inline fun <E, T : Result<E>> isSuccess(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

data class Right<R> : Either<Nothing, R>

Right(r: R)
val r: R

object RootAssertionGroupType : AssertionGroupType
interface RootExpect<T> : Expect<T>

operator fun <T> invoke(maybeSubject: Option<T>, assertionVerb: Translatable, expectOptions: RootExpectOptions<T>?): RootExpect<T>
operator fun <T> invoke(rootExpect: RootExpect<T>, expectOptions: RootExpectOptions<T>): RootExpect<T>

data class RootExpectOptions<T>

RootExpectOptions(assertionVerb: Translatable?, representationInsteadOfSubject: ((T) -> Any)?, reporter: Reporter?)
val assertionVerb: Translatable?
fun merge(options: RootExpectOptions<T>): RootExpectOptions<T>
val reporter: Reporter?
val representationInsteadOfSubject: ((T) -> Any)?

interface SearchBehaviourFactory

abstract fun <T : CharSequence> ignoringCase(containsBuilder: CharSequenceContains.Builder<T, NoOpSearchBehaviour>): CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>

interface SearchBehaviourFactory

abstract fun <E, T : Iterable<E>> inAnyOrder(builder: IterableContains.Builder<E, T, NoOpSearchBehaviour>): IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>): IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrder(builder: IterableContains.Builder<E, T, NoOpSearchBehaviour>): IterableContains.Builder<E, T, InOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContains.Builder<E, T, InOrderSearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

data class Some<T> : Option<T>

Some(value: T)
val value: T

data class StringBasedRawString : RawString

val string: String

interface StringBasedTranslatable : Translatable

open fun getDefault(): String
abstract val value: String

interface SubjectBasedOption

interface AbsentOption<T, R>

open infix fun ifAbsent(failureHintFactory: () -> R): Pair<() -> R, (T) -> R>
abstract val ifDefined: (T) -> R

interface DefinedOption<T, R, AO : SubjectBasedOption.AbsentOption<T, R>>

abstract fun ifDefined(failureHintFactory: (T) -> R): AO

operator fun <T, R, PO : SubjectBasedOption.DefinedOption<T, R, *>> invoke(subjectProvider: SubjectProvider<T>, subStep: PO.() -> Pair<() -> R, (T) -> R>, presentOptionFactory: () -> PO): R

interface SubjectChanger

interface FailureHandler<T, R>

abstract fun createAssertion(container: AssertionContainer<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion

abstract fun <T, R> reported(container: AssertionContainer<T>, description: Translatable, representation: Any, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>): Expect<R>
abstract fun <T, R> unreported(container: AssertionContainer<T>, transformation: (T) -> R): Expect<R>

interface SubjectChanger

interface FailureHandler<T, R>

abstract fun createAssertion(originalAssertionContainer: Expect<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion

abstract fun <T, R> reported(originalAssertionContainer: Expect<T>, description: Translatable, representation: Any, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>): Expect<R>
abstract fun <T, R> unreported(originalAssertionContainer: Expect<T>, transformation: (T) -> R): Expect<R>
abstract fun <T, R> unreportedNullableToAssert(originalPlant: SubjectProvider<T>, transformation: (T) -> R): AssertionPlantNullable<R>
abstract fun <T, R : Any> unreportedToAssert(originalPlant: SubjectProvider<T>, transformation: (T) -> R): Assert<R>

interface SubjectChangerBuilder

interface DescriptionRepresentationStep<T>

abstract val container: AssertionContainer<T>
open fun <TSub : Any> downCastTo(subType: KClass<TSub>): SubjectChangerBuilder.FailureHandlerStep<T, TSub>
operator fun <T> invoke(container: AssertionContainer<T>): SubjectChangerBuilder.DescriptionRepresentationStep<T>
open fun withDescriptionAndRepresentation(description: String, representation: Any?): SubjectChangerBuilder.TransformationStep<T>
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): SubjectChangerBuilder.TransformationStep<T>

interface ExecutionStep<T, R> : TransformationExecutionStep<T, R, Expect<R>>

operator fun <T, R> invoke(container: AssertionContainer<T>, action: (AssertionContainer<T>) -> Expect<R>, actionAndApply: (AssertionContainer<T>, Expect<R>.() -> Unit) -> Expect<R>): SubjectChangerBuilder.ExecutionStep<T, R>

interface FailureHandlerStep<T, R>

open fun build(): SubjectChangerBuilder.ExecutionStep<T, R>
operator fun <T, R> invoke(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerStep<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>
abstract fun withDefaultFailureHandler(): SubjectChangerBuilder.FinalStep<T, R>
abstract fun withFailureHandler(failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
open fun <R1> withFailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1): SubjectChangerBuilder.FinalStep<T, R>

interface FinalStep<T, R>

abstract fun build(): SubjectChangerBuilder.ExecutionStep<T, R>
abstract val failureHandler: SubjectChanger.FailureHandler<T, R>
operator fun <T, R> invoke(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>

operator fun <T> invoke(container: AssertionContainer<T>): SubjectChangerBuilder.KindStep<T>
interface KindStep<T>

abstract val container: AssertionContainer<T>
abstract fun reportBuilder(): SubjectChangerBuilder.DescriptionRepresentationStep<T>
open fun <R> unreported(transformation: (T) -> R): Expect<R>

interface TransformationStep<T>

abstract val container: AssertionContainer<T>
abstract val description: Translatable
operator fun <T> invoke(container: AssertionContainer<T>, description: Translatable, representation: Any): SubjectChangerBuilder.TransformationStep<T>
abstract val representation: Any
abstract fun <R> withTransformation(transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerStep<T, R>

interface SubjectChangerBuilder

fun <T> create(expect: Expect<T>): SubjectChangerBuilder.KindStep<T>
fun <T> create(originalPlant: SubjectProvider<T>): SubjectChangerBuilder.DeprecatedKindStep<T>
interface DeprecatedKindStep<T>

abstract val originalPlant: SubjectProvider<T>
open fun <R : Any> unreported(transformation: (T) -> R): Assert<R>
open fun <R> unreportedNullable(transformation: (T) -> R): AssertionPlantNullable<R>

interface DescriptionRepresentationStep<T>

fun <T> create(originalAssertionContainer: Expect<T>): SubjectChangerBuilder.DescriptionRepresentationStep<T>
open fun <TSub : Any> downCastTo(subType: KClass<TSub>): SubjectChangerBuilder.FailureHandlerOption<T, TSub>
abstract val originalExpect: Expect<T>
open fun withDescriptionAndRepresentation(description: String, representation: Any?): SubjectChangerBuilder.TransformationStep<T>
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): SubjectChangerBuilder.TransformationStep<T>

interface FailureHandlerOption<T, R>

open fun build(): ChangedSubjectPostStep<T, R>
fun <T, R> create(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerOption<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>
abstract fun withDefaultFailureHandler(): SubjectChangerBuilder.FinalStep<T, R>
abstract fun withFailureHandler(failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
open fun <R1> withFailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1): SubjectChangerBuilder.FinalStep<T, R>

interface FinalStep<T, R>

abstract fun build(): ChangedSubjectPostStep<T, R>
fun <T, R> create(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
abstract val failureHandler: SubjectChanger.FailureHandler<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>

interface KindStep<T>

abstract val originalExpect: Expect<T>
abstract fun reportBuilder(): SubjectChangerBuilder.DescriptionRepresentationStep<T>
open fun <R> unreported(transformation: (T) -> R): Expect<R>

interface TransformationStep<T>

fun <T> create(originalAssertionContainer: Expect<T>, description: Translatable, representation: Any): SubjectChangerBuilder.TransformationStep<T>
abstract val description: Translatable
abstract val originalExpect: Expect<T>
abstract val representation: Any
abstract fun <R> withTransformation(transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerOption<T, R>

interface SubjectProvider<out T> : AssertionHolder

abstract val maybeSubject: Option<T>
abstract val subject: T

object success : Keyword
class Success<out T> : IoResult<T>

Success(path: Path, value: T)
val value: T

data class SuccessWithCreator<E>

val assertionCreator: Expect<E>.() -> Unit

interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType
data class Text

val EMPTY: Text
operator fun invoke(string: String): Text
val NULL: Text
val string: String

expect interface TextAssertionFormatterOption : TextAssertionFormatterOptionCommon

fun create(options: AssertionFormatterChosenOptions, assertionPairFormatter: AssertionPairFormatter): TextAssertionFormatterOption
open fun withDefaultTextCapabilities(vararg bulletPoints: Pair<Class<out BulletPointIdentifier>, String>): ReporterOption

interface TextAssertionFormatterOptionCommon

abstract val assertionPairFormatter: AssertionPairFormatter
abstract val options: AssertionFormatterChosenOptions
abstract fun withTextAssertionFormatter(factory: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter, vararg otherFactories: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter): AtriumErrorAdjusterOption
abstract fun withTextCapabilities(vararg bulletPoints: Pair<KClass<out BulletPointIdentifier>, String>): AtriumErrorAdjusterOption

interface ThrowableAssertions

abstract fun <TExpected : Throwable> causeIsA(container: AssertionContainer<out Throwable>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected>

interface ThrowableAssertions

abstract fun <TExpected : Throwable> cause(expect: Expect<out Throwable>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<Throwable?, TExpected>
open fun thrownBuilder(assertionVerb: String, act: () -> Unit, reporter: Reporter): ThrowableThrown.Builder
abstract fun thrownBuilder(assertionVerb: Translatable, act: () -> Unit, reporter: Reporter): ThrowableThrown.Builder

object ThrowableAssertionsBuilder : ThrowableAssertions

inline fun <TExpected : Throwable> cause(expect: Expect<out Throwable>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<Throwable?, TExpected>
inline val thrown: ThrowableThrownAssertionsBuilder
inline fun thrownBuilder(assertionVerb: Translatable, noinline act: () -> Unit, reporter: Reporter): ThrowableThrown.Builder

interface ThrowableThrown

interface AbsentThrowableMessageProvider

abstract val message: RawString

interface Builder

abstract val act: () -> Unit
abstract val assertionVerb: Translatable
abstract val reporter: Reporter

interface Creator<TExpected : Throwable>

abstract fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrown.Builder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit
abstract fun executeActAssertNothingThrown(throwableThrownBuilder: ThrowableThrown.Builder): Unit

interface ThrowableThrown

interface AbsentThrowableMessageProvider

abstract val message: RawString

interface Creator<TExpected : Throwable>

abstract fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrownBuilder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

class ThrowableThrownAssertionCreator<TExpected : Throwable> : ThrowableThrown.Creator<TExpected>

ThrowableThrownAssertionCreator(absentThrowableMessageProvider: ThrowableThrown.AbsentThrowableMessageProvider, failureHandler: AnyTypeTransformation.TypeTransformationFailureHandler<Throwable, TExpected>)
fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrownBuilder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

interface ThrowableThrownAssertions

abstract fun nothingThrown(throwableThrownBuilder: ThrowableThrown.Builder): Unit
abstract fun <TExpected : Throwable> toBe(throwableThrownBuilder: ThrowableThrown.Builder, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

object ThrowableThrownAssertionsBuilder : ThrowableThrownAssertions

inline fun nothingThrown(throwableThrownBuilder: ThrowableThrown.Builder): Unit
inline val providers: AbsentThrowableMessageProviderFactoryBuilder
inline fun <TExpected : Throwable> toBe(throwableThrownBuilder: ThrowableThrown.Builder, expectedType: KClass<TExpected>, noinline assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

class ThrowableThrownBuilder : ThrowableThrown.Builder

ThrowableThrownBuilder(assertionVerb: Translatable, act: () -> Unit, reporter: Reporter)
val act: () -> Unit
val assertionVerb: Translatable
val reporter: Reporter

class ThrowableThrownFailureHandler<T : Throwable?, R> : SubjectChanger.FailureHandler<T, R>

ThrowableThrownFailureHandler()
fun createAssertion(container: AssertionContainer<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion
fun createChildHint(throwable: Throwable, child: Throwable, childDescription: Translatable): AssertionGroup
fun propertiesOfThrowable(throwable: Throwable, explanation: Assertion = createExplanation(throwable)): AssertionGroup

interface ThrowingAssertionCollectorForExplanation : AssertionCollectorForExplanation
interface TransformationExecutionStep<T, R, E : Expect<R>>

abstract fun collect(assertionCreator: Expect<R>.() -> Unit): Assertion
abstract fun collectAndAppend(assertionCreator: Expect<R>.() -> Unit): Expect<T>
abstract fun transform(): E
abstract fun transformAndAppend(assertionCreator: Expect<R>.() -> Unit): Expect<R>

class TransformationStepImpl<T> : SubjectChangerBuilder.TransformationStep<T>

TransformationStepImpl(container: AssertionContainer<T>, description: Translatable, representation: Any)
val container: AssertionContainer<T>
val description: Translatable
val representation: Any
fun <R> withTransformation(transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerStep<T, R>

interface Translatable

abstract fun getDefault(): String
open val id: String
const val ID_SEPARATOR: String
abstract val name: String

class TranslatableAsAbsentThrowableMessageProvider : ThrowableThrown.AbsentThrowableMessageProvider

TranslatableAsAbsentThrowableMessageProvider(translatable: Translatable)
val message: RawString

data class TranslatableBasedRawString : RawString

val translatable: Translatable

data class TranslatableWithArgs : Translatable

TranslatableWithArgs(translatable: Translatable, argument: Any)
TranslatableWithArgs(translatable: Translatable, arg1: Any, arg2: Any)
TranslatableWithArgs(translatable: Translatable, arg1: Any, arg2: Any, vararg otherArgs: Any)
TranslatableWithArgs(translatable: Translatable, arguments: List<Any>)
val arguments: List<Any>
fun getDefault(): String
val name: String
val translatable: Translatable

interface TranslationSupplier

abstract fun get(translatable: Translatable, locale: Locale): String?

interface Translator

abstract fun translate(translatable: Translatable): String

expect interface TranslatorOption : TranslatorOptionCommon

open fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ObjectFormatterOption

interface TranslatorOptionCommon

abstract val localeOrderDecider: LocaleOrderDecider
abstract val translationSupplier: TranslationSupplier
abstract fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ObjectFormatterOption
abstract fun withTranslator(factory: (TranslationSupplier, LocaleOrderDecider) -> Translator): ObjectFormatterOption

class TypeTransformer<T : Any, TSub : Any>

TypeTransformer(failureHandler: AnyTypeTransformation.TypeTransformationFailureHandler<T, TSub>)
fun transform(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, warningTransformationFailed: Translatable, canBeTransformed: (T) -> Boolean, transform: (T) -> TSub): Unit

class Untranslatable : Translatable

Untranslatable(representation: CharSequence)
Untranslatable(representation: () -> String)
Untranslatable(representation: String)
val EMPTY: Untranslatable
fun getDefault(): String
val name: String
fun toString(): String

class UsingDefaultTranslator : ArgumentsSupportingTranslator

UsingDefaultTranslator(primaryLocale: Locale = getDefaultLocale())
protected fun translateWithoutArgs(translatable: Translatable): String

data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): List<T>

data class Value<T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

val expected: T
fun toList(): List<T>

data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): List<T>

data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): List<T>

class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

val expected: T
val otherExpected: Array<out T>
fun toList(): List<T>

class Values<out T>

Values(objects: Objects<T>)
Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

interface VarArgHelper<out T>

abstract val expected: T
open val mapArguments: ArgumentMapperBuilder<T>
abstract val otherExpected: Array<out T>
open fun toList(): List<T>

object WarningAssertionGroupType : ExplanatoryAssertionGroupType
data class Wert<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

Wert(expected: T)
val expected: T
fun toList(): List<T>

class Werte<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

Werte(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

interface WithTimesChecker : Contains.Checker

abstract val times: Int

interface WithTimesCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>

abstract val times: Int

interface WithTimesCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>

abstract val times: Int

interface WithTimesCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
interface WithTimesCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
interface WithTimesCheckerStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>, WithTimesCheckerStepLogic<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
interface WithTimesCheckerStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>, WithTimesCheckerStepLogic<E, T, S>, IterableLikeContains.CheckerStepInternal<E, T, S>
interface WithTimesCheckerStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStepLogic<T, S>

abstract val times: Int

interface WithTimesCheckerStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStepLogic<E, T, S>

abstract val times: Int

object writable : Keyword
interface ZonedDateTimeAssertions

abstract fun day(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>
abstract fun dayOfWeek(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, DayOfWeek>
abstract fun month(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>
abstract fun year(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>

interface ZonedDateTimeAssertions

abstract fun <T : ZonedDateTime> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : ZonedDateTime> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
abstract fun <T : ZonedDateTime> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : ZonedDateTime> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

object ZonedDateTimeAssertionsBuilder : ZonedDateTimeAssertions

inline fun <T : ZonedDateTime> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : ZonedDateTime> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
inline fun <T : ZonedDateTime> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : ZonedDateTime> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

package ch.tutteli.atrium

interface IAtriumFactory

abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subject: T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: AssertionPlantWithCommonFields.CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subject: T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: AssertionPlantWithCommonFields.CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, vararg fallbackLocales: Locale): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit

package ch.tutteli.atrium.api.cc.de_CH

fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerOption<T, S>.aberHoechstens(times: Int): ButAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.aberHoechstens(times: Int): ButAtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> aberHoechstens(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>> aberHoechstens(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
fun <E : Any, T : Iterable<E?>> Assert<T>.alle(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.alleDerNullable(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <K, V> Assert<Map<out K, V>>.asEntries(): Assert<Set<Entry<K, V>>>
fun <K, V> Assert<Map<out K, V>>.asEntries(assertionCreator: Assert<Set<Entry<K, V>>>.() -> Unit): Assert<Set<Entry<K, V>>>
fun <E> Assert<Array<out E>>.asIterable(): Assert<Iterable<E>>
fun <E> Assert<Array<out E>>.asIterable(assertionCreator: Assert<Iterable<E>>.() -> Unit): Assert<Iterable<E>>
@JvmName("byteArrAsIterable") fun Assert<ByteArray>.asIterable(): Assert<Iterable<Byte>>
@JvmName("byteArrAsIterable") fun Assert<ByteArray>.asIterable(assertionCreator: Assert<Iterable<Byte>>.() -> Unit): Assert<Iterable<Byte>>
@JvmName("charArrAsIterable") fun Assert<CharArray>.asIterable(): Assert<Iterable<Char>>
@JvmName("charArrAsIterable") fun Assert<CharArray>.asIterable(assertionCreator: Assert<Iterable<Char>>.() -> Unit): Assert<Iterable<Char>>
@JvmName("shortArrAsIterable") fun Assert<ShortArray>.asIterable(): Assert<Iterable<Short>>
@JvmName("shortArrAsIterable") fun Assert<ShortArray>.asIterable(assertionCreator: Assert<Iterable<Short>>.() -> Unit): Assert<Iterable<Short>>
@JvmName("intArrAsIterable") fun Assert<IntArray>.asIterable(): Assert<Iterable<Int>>
@JvmName("intArrAsIterable") fun Assert<IntArray>.asIterable(assertionCreator: Assert<Iterable<Int>>.() -> Unit): Assert<Iterable<Int>>
@JvmName("longArrAsIterable") fun Assert<LongArray>.asIterable(): Assert<Iterable<Long>>
@JvmName("longArrAsIterable") fun Assert<LongArray>.asIterable(assertionCreator: Assert<Iterable<Long>>.() -> Unit): Assert<Iterable<Long>>
@JvmName("floatArrAsIterable") fun Assert<FloatArray>.asIterable(): Assert<Iterable<Float>>
@JvmName("floatArrAsIterable") fun Assert<FloatArray>.asIterable(assertionCreator: Assert<Iterable<Float>>.() -> Unit): Assert<Iterable<Float>>
@JvmName("doubleArrAsIterable") fun Assert<DoubleArray>.asIterable(): Assert<Iterable<Double>>
@JvmName("doubleArrAsIterable") fun Assert<DoubleArray>.asIterable(assertionCreator: Assert<Iterable<Double>>.() -> Unit): Assert<Iterable<Double>>
@JvmName("boolArrAsIterable") fun Assert<BooleanArray>.asIterable(): Assert<Iterable<Boolean>>
@JvmName("boolArrAsIterable") fun Assert<BooleanArray>.asIterable(assertionCreator: Assert<Iterable<Boolean>>.() -> Unit): Assert<Iterable<Boolean>>
fun <E> Assert<Sequence<E>>.asIterable(): Assert<Iterable<E>>
fun <T : CharSequence> Assert<T>.beginntMit(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.beginntNichtMit(expected: CharSequence): AssertionPlant<T>
object CharSequenceContainsSearchersKt

@JvmStatic fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> standardUebersetzungVon(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> wert(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> werte(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>

fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.eintraege(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.eintraege(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.eintraege(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
class Eintraege<in T : Any> : GroupWithoutNullableEntries<((Assert<T>) -> Unit)?>, GroupWithNullableEntries<((Assert<T>) -> Unit)?>, VarArgHelper<((Assert<T>) -> Unit)?>

Eintraege(assertionCreatorOrNull: ((Assert<T>) -> Unit)?, vararg otherAssertionCreatorsOrNulls: ((Assert<T>) -> Unit)?)
val assertionCreatorOrNull: ((Assert<T>) -> Unit)?
val expected: ((Assert<T>) -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<((Assert<T>) -> Unit)?>
val otherExpected: Array<((Assert<T>) -> Unit)?>
fun toList(): List<((Assert<T>) -> Unit)?>

fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.eintrag(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.eintrag(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.eintrag(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
class Eintrag<in T : Any> : GroupWithoutNullableEntries<((Assert<T>) -> Unit)?>, GroupWithNullableEntries<((Assert<T>) -> Unit)?>

Eintrag(assertionCreator: ((Assert<T>) -> Unit)?)
val assertionCreator: ((Assert<T>) -> Unit)?
fun toList(): List<((Assert<T>) -> Unit)?>

fun <T : CharSequence> Assert<T>.endetMit(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endetNichtMit(expected: CharSequence): AssertionPlant<T>
val <T : CharSequence> Assert<T>.enthaelt: CharSequenceContains.Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.enthaelt(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaelt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaelt(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaelt(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <K, V, T : Map<out K, V>> Assert<T>.enthaelt(entry: Pair<K, V>, vararg otherEntries: Pair<K, V>): AssertionPlant<T>
fun <K, V : Any, T : Map<out K, V?>> Assert<T>.enthaelt(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltExakt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltExakt(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltExakt(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <K> Assert<Map<out K, *>>.enthaeltKey(key: K): AssertionPlant<Map<out K, *>>
val <T : CharSequence> Assert<T>.enthaeltNicht: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.enthaeltNicht(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNicht(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltNichtDieStandardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <K> Assert<Map<out K, *>>.enthaeltNichtKey(key: K): AssertionPlant<Map<out K, *>>
fun <E, T : Iterable<E>> enthaeltNichtNonNullable(plant: Assert<T>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltNullableEintraege(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltNullableEintrag(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltStandardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmName("enthaeltStriktDeprecated") fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStrikt(assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaeltStrikt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> enthaeltStriktNullable(plant: Assert<T>, assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStriktNullableEintraege(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStriktNullableEintrag(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltStriktNullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltStriktNullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <K : Any> Assert<Pair<K, *>>.first: Assert<K>
fun <K : Any, V> Assert<Pair<K, V>>.first(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Pair<K, V>>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.genau(times: Int): ExactlyCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.genau(times: Int): ExactlyCheckerOption<E, T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> genau(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
fun <E, T : Iterable<E>> genau(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
fun <E : Any, T : List<E>> Assert<T>.get(index: Int): Assert<E>
fun <E : Any, T : List<E>> Assert<T>.get(index: Int, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> getEnthaelt(plant: Assert<T>): CharSequenceContainsBuilder<T, NoOpSearchBehaviour>
fun <T : CharSequence> getEnthaeltNicht(plant: Assert<T>): CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>
fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExistierend(key: K): Assert<V>
fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExistierend(key: K, assertionCreator: Assert<V>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> getIgnoriereGrossKleinschreibung(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> getIgnoriereGrossKleinschreibung(builder: CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> getInBeliebigerReihenfolge(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> getInGegebenerReihenfolge(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.gruppiert: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
fun <T : Collection<*>> Assert<T>.hatDieGroesse(size: Int): AssertionPlant<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.hoechstens(times: Int): AtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.hoechstens(times: Int): AtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> hoechstens(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>> hoechstens(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
val <T : CharSequence> CharSequenceContains.Builder<T, NoOpSearchBehaviour>.ignoriereGrossKleinschreibung: CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoriereGrossKleinschreibung: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inBeliebigerReihenfolge: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): AssertionPlant<T>
@JvmName("inBeliebigerReihenfolgeEintraege") fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: Group<(Assert<E>.() -> Unit)?>, secondGroup: Group<(Assert<E>.() -> Unit)?>, vararg otherExpectedGroups: Group<(Assert<E>.() -> Unit)?>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> inBeliebigerReihenfolge(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithoutNullableEntries<E>, secondGroup: GroupWithoutNullableEntries<E>, vararg otherExpectedGroups: GroupWithoutNullableEntries<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> inBeliebigerReihenfolge(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithNullableEntries<E>, secondGroup: GroupWithNullableEntries<E>, vararg otherExpectedGroups: GroupWithNullableEntries<E>): AssertionPlant<T>
@JvmName("inBeliebigerReihenfolgeEintraege") fun <E : Any, T : Iterable<E>> inBeliebigerReihenfolge(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithoutNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
@JvmName("inBeliebigerReihenfolgeNullableEintraege") fun <E : Any, T : Iterable<E?>> inBeliebigerReihenfolge(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithNullableEntries<(Assert<E>.() -> Unit)?>, secondGroup: GroupWithNullableEntries<(Assert<E>.() -> Unit)?>, vararg otherExpectedGroups: GroupWithNullableEntries<(Assert<E>.() -> Unit)?>): AssertionPlant<T>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inGegebenerReihenfolge: IterableContains.Builder<E, T, InOrderSearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.innerhalb: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
fun <E : Any, T : Iterable<E?>> Assert<T>.irgendEiner(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.irgendEinNullable(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <T : Any> Assert<T>.ist(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.ist(expected: T?): Unit
fun <T> ist(plant: AssertionPlantNullable<T>, void: Void?): Unit
inline fun <reified TSub : Any> Assert<Any>.istEin(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun Assert<Boolean>.istFalse(): AssertionPlant<Boolean>
fun <T : BigDecimal> Assert<T>.istGleichInklusiveScale(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istGroesserAls(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istGroesserOderGleich(expected: T): AssertionPlant<T>
fun <K : Any, V : Any> Assert<Entry<K, V>>.istKeyValue(key: K, value: V): Assert<Entry<K, V>>
fun <T : Comparable<T>> Assert<T>.istKleinerAls(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istKleinerOderGleich(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istLeer(): AssertionPlant<T>
fun Assert<Float>.istMitFehlerToleranz(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.istMitFehlerToleranz(expected: Double, tolerance: Double): AssertionPlant<Double>
fun <T : BigDecimal> Assert<T>.istMitFehlerToleranz(expected: T, tolerance: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istNicht(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istNichtBlank(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.istNichtGleichInklusiveScale(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istNichtLeer(): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.istNichtNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
infix fun <T : BigDecimal> AssertionPlantNullable<T?>.istNichtNullAber(expected: T): Nothing
fun <T : BigDecimal> Assert<T>.istNichtNumerischGleichWie(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istNichtSelbeInstanzWie(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.istNull(): Unit
inline fun <reified T : Any> AssertionPlantNullable<T?>.istNullWennNullGegebenSonst(noinline assertionCreatorOrNull: (Assert<T>.() -> Unit)?): Unit
fun <T : BigDecimal> Assert<T>.istNumerischGleichWie(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istSelbeInstanzWie(expected: T): AssertionPlant<T>
fun Assert<Boolean>.istTrue(): AssertionPlant<Boolean>
fun <E : Any, T : Iterable<E?>> Assert<T>.keiner(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.keinerDerNullable(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
val <K : Any> Assert<Entry<K, *>>.key: Assert<K>
fun <K : Any, V> Assert<Entry<K, V>>.key(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Entry<K, V>>
data class KeyNullableValue<out K, V : Any>

KeyNullableValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

val <K, V> Assert<Map<out K, V>>.keys: Assert<Set<K>>
fun <K, V, T : Map<out K, V>> Assert<T>.keys(assertionCreator: Assert<Set<K>>.() -> Unit): AssertionPlant<T>
data class KeyValue<out K, V : Any>

KeyValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : Throwable> Assert<T>.messageEnthaelt(expected: Any, vararg otherExpected: Any): Unit
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.nichtOderHoechstens(times: Int): NotOrAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.nichtOderHoechstens(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> nichtOderHoechstens(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>> nichtOderHoechstens(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
class NullableEintraege<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEintraege(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEintraege(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEintraege(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEintraege(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
class NullableEintrag<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEintrag(assertionCreator: (Assert<T>.() -> Unit)?)
val assertionCreator: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEintrag(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEintrag(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEintrag(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
data class NullableWert<T> : GroupWithNullableEntries<T>

NullableWert(expected: T)
val expected: T
fun toList(): List<T>

fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
class NullableWerte<T> : GroupWithNullableEntries<T>

NullableWerte(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): List<T>

fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>.nur: IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderSearchBehaviour>.nur: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmName("regexIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction0<R>): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("sicherRueckgabewertVon") fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
val <V : Any> Assert<Pair<*, V>>.second: Assert<V>
fun <K, V : Any> Assert<Pair<K, V>>.second(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Pair<K, V>>
val Assert<Collection<*>>.size: Assert<Int>
fun <E, T : Collection<E>> Assert<T>.size(assertionCreator: Assert<Int>.() -> Unit): Assert<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.standardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmName("standardUebersetzungVonGrossKleinschreibungIgnorierend") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.standardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
val <T : Any> Assert<T>.und: Assert<T>
infix fun <T : Any> AssertionPlant<T>.und(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
val <V : Any> Assert<Entry<*, V>>.value: Assert<V>
fun <K, V : Any> Assert<Entry<K, V>>.value(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Entry<K, V>>
val <K, V> Assert<Map<out K, V>>.values: Assert<Collection<V>>
fun <K, V, T : Map<out K, V>> Assert<T>.values(assertionCreator: Assert<Collection<V>>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
@JvmName("wertGrossKleinschreibungIgnorierend") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
data class Wert<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

Wert(expected: T)
val expected: T
fun toList(): List<T>

fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
@JvmName("werteGrossKleinschreibungIgnorierend") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
class Werte<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

Werte(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

inline fun <reified TExpected : Throwable> ThrowableThrown.Builder.wirft(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
inline fun <reified TExpected : Throwable> ThrowableThrown.Builder.wirft(): Unit
fun ThrowableThrown.Builder.wirftNichts(): Unit
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.zumindest(times: Int): AtLeastCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.zumindest(times: Int): AtLeastCheckerOption<E, T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> zumindest(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
fun <E, T : Iterable<E>> zumindest(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>

package ch.tutteli.atrium.api.cc.de_CH.assertions.charsequence.contains.builders

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

package ch.tutteli.atrium.api.cc.de_CH.assertions.iterable.contains.builders

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

package ch.tutteli.atrium.api.cc.de_CH.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>

package ch.tutteli.atrium.api.cc.de_CH.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

package ch.tutteli.atrium.api.cc.en_GB

fun <E : Any, T : Iterable<E?>> Assert<T>.all(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.allOfNullable(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
val <T : Any> AssertionPlant<T>.and: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.any(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.anyOfNullable(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <K, V> Assert<Map<out K, V>>.asEntries(): Assert<Set<Entry<K, V>>>
fun <K, V> Assert<Map<out K, V>>.asEntries(assertionCreator: Assert<Set<Entry<K, V>>>.() -> Unit): Assert<Set<Entry<K, V>>>
fun <E> Assert<Array<out E>>.asIterable(): Assert<Iterable<E>>
fun <E> Assert<Array<out E>>.asIterable(assertionCreator: Assert<Iterable<E>>.() -> Unit): Assert<Iterable<E>>
@JvmName("byteArrAsIterable") fun Assert<ByteArray>.asIterable(): Assert<Iterable<Byte>>
@JvmName("byteArrAsIterable") fun Assert<ByteArray>.asIterable(assertionCreator: Assert<Iterable<Byte>>.() -> Unit): Assert<Iterable<Byte>>
@JvmName("charArrAsIterable") fun Assert<CharArray>.asIterable(): Assert<Iterable<Char>>
@JvmName("charArrAsIterable") fun Assert<CharArray>.asIterable(assertionCreator: Assert<Iterable<Char>>.() -> Unit): Assert<Iterable<Char>>
@JvmName("shortArrAsIterable") fun Assert<ShortArray>.asIterable(): Assert<Iterable<Short>>
@JvmName("shortArrAsIterable") fun Assert<ShortArray>.asIterable(assertionCreator: Assert<Iterable<Short>>.() -> Unit): Assert<Iterable<Short>>
@JvmName("intArrAsIterable") fun Assert<IntArray>.asIterable(): Assert<Iterable<Int>>
@JvmName("intArrAsIterable") fun Assert<IntArray>.asIterable(assertionCreator: Assert<Iterable<Int>>.() -> Unit): Assert<Iterable<Int>>
@JvmName("longArrAsIterable") fun Assert<LongArray>.asIterable(): Assert<Iterable<Long>>
@JvmName("longArrAsIterable") fun Assert<LongArray>.asIterable(assertionCreator: Assert<Iterable<Long>>.() -> Unit): Assert<Iterable<Long>>
@JvmName("floatArrAsIterable") fun Assert<FloatArray>.asIterable(): Assert<Iterable<Float>>
@JvmName("floatArrAsIterable") fun Assert<FloatArray>.asIterable(assertionCreator: Assert<Iterable<Float>>.() -> Unit): Assert<Iterable<Float>>
@JvmName("doubleArrAsIterable") fun Assert<DoubleArray>.asIterable(): Assert<Iterable<Double>>
@JvmName("doubleArrAsIterable") fun Assert<DoubleArray>.asIterable(assertionCreator: Assert<Iterable<Double>>.() -> Unit): Assert<Iterable<Double>>
@JvmName("boolArrAsIterable") fun Assert<BooleanArray>.asIterable(): Assert<Iterable<Boolean>>
@JvmName("boolArrAsIterable") fun Assert<BooleanArray>.asIterable(assertionCreator: Assert<Iterable<Boolean>>.() -> Unit): Assert<Iterable<Boolean>>
fun <E> Assert<Sequence<E>>.asIterable(): Assert<Iterable<E>>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
val <T : CharSequence> Assert<T>.contains: CharSequenceContains.Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.contains(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.contains(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.contains(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.contains(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <K, V, T : Map<out K, V>> Assert<T>.contains(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): AssertionPlant<T>
fun <K, V : Any, T : Map<out K, V?>> Assert<T>.contains(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsExactly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <K> Assert<Map<out K, *>>.containsKey(key: K): AssertionPlant<Map<out K, *>>
val <T : CharSequence> Assert<T>.containsNot: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.containsNot(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <K> Assert<Map<out K, *>>.containsNotKey(key: K): AssertionPlant<Map<out K, *>>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.entries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
class Entries<in T : Any> : GroupWithoutNullableEntries<(Assert<T>.() -> Unit)?>, GroupWithNullableEntries<(Assert<T>.() -> Unit)?>, VarArgHelper<(Assert<T>.() -> Unit)?>

Entries(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
val expected: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
val otherExpected: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
class Entry<in T : Any> : GroupWithoutNullableEntries<(Assert<T>.() -> Unit)?>, GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

Entry(assertionCreatorOrNull: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
val <K : Any> Assert<Pair<K, *>>.first: Assert<K>
fun <K : Any, V> Assert<Pair<K, V>>.first(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Pair<K, V>>
fun <E : Any, T : List<E>> Assert<T>.get(index: Int): Assert<E>
fun <E : Any, T : List<E>> Assert<T>.get(index: Int, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: K): Assert<V>
fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: K, assertionCreator: Assert<V>.() -> Unit): AssertionPlant<T>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.grouped: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
val <T : CharSequence> CharSequenceContains.Builder<T, NoOpSearchBehaviour>.ignoringCase: CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoringCase: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
@JvmName("inAnyOrderNullableValues") fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): AssertionPlant<T>
@JvmName("inAnyOrderNullableEntries") fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<(Assert<E>.() -> Unit)?>, secondGroup: Group<(Assert<E>.() -> Unit)?>, vararg otherExpectedGroups: Group<(Assert<E>.() -> Unit)?>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> inAnyOrder(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithoutNullableEntries<E>, secondGroup: GroupWithoutNullableEntries<E>, vararg otherExpectedGroups: GroupWithoutNullableEntries<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> inAnyOrder(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithNullableEntries<E>, secondGroup: GroupWithNullableEntries<E>, vararg otherExpectedGroups: GroupWithNullableEntries<E>): AssertionPlant<T>
@JvmName("inAnyOrderEntries") fun <E : Any, T : Iterable<E>> inAnyOrder(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithoutNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
@JvmName("inAnyOrderNullableEntries") fun <E : Any, T : Iterable<E?>> inAnyOrder(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithNullableEntries<(Assert<E>.() -> Unit)?>, secondGroup: GroupWithNullableEntries<(Assert<E>.() -> Unit)?>, vararg otherExpectedGroups: GroupWithNullableEntries<(Assert<E>.() -> Unit)?>): AssertionPlant<T>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inAnyOrder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inOrder: IterableContains.Builder<E, T, InOrderSearchBehaviour>
inline fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> Assert<T>.isEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
fun <K : Any, V : Any> Assert<Entry<K, V>>.isKeyValue(key: K, value: V): Assert<Entry<K, V>>
fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotBlank(): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isNotSameAs(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isSameAs(expected: T): AssertionPlant<T>
val <K : Any> Assert<Entry<K, *>>.key: Assert<K>
fun <K : Any, V> Assert<Entry<K, V>>.key(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Entry<K, V>>
data class KeyNullableValue<out K, V : Any>

KeyNullableValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

val <K> Assert<Map<K, *>>.keys: Assert<Set<K>>
fun <K, V, T : Map<K, V>> Assert<T>.keys(assertionCreator: Assert<Set<K>>.() -> Unit): AssertionPlant<T>
data class KeyValue<out K, V : Any>

KeyValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : Throwable> Assert<T>.messageContains(expected: Any, vararg otherExpected: Any): Unit
fun <E : Any, T : Iterable<E?>> Assert<T>.none(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.noneOfNullable(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <T : BigDecimal> AssertionPlantNullable<T?>.notToBeNullBut(expected: T): Nothing
fun ThrowableThrown.Builder.notToThrow(): Unit
class NullableEntries<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEntries(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntries(assertionCreatorOrNull: (Assert<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<E>.() -> Unit)?): AssertionPlant<T>
class NullableEntry<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEntry(assertionCreator: (Assert<T>.() -> Unit)?)
val assertionCreator: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

infix fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
data class NullableValue<T> : GroupWithNullableEntries<T>

NullableValue(expected: T)
val expected: T
fun toList(): List<T>

infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
class NullableValues<T> : GroupWithNullableEntries<T>

NullableValues(expected: T, vararg otherExpected: T)
vararg val otherExpected: Array<out T>
fun toList(): List<T>

fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>.only: IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderSearchBehaviour>.only: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmName("regexIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
val <V : Any> Assert<Pair<*, V>>.second: Assert<V>
fun <K, V : Any> Assert<Pair<K, V>>.second(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Pair<K, V>>
val Assert<Collection<*>>.size: Assert<Int>
fun <E, T : Collection<E>> Assert<T>.size(assertionCreator: Assert<Int>.() -> Unit): Assert<T>
fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.toBe(expected: T?): Unit
fun <T> toBe(plant: AssertionPlantNullable<T>, void: Void?): Unit
inline fun <reified T : Any> AssertionPlantNullable<T?>.toBeNullIfNullGivenElse(noinline assertionCreatorOrNull: (Assert<T>.() -> Unit)?): Unit
fun Assert<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): AssertionPlant<Double>
fun Assert<BigDecimal>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): AssertionPlant<BigDecimal>
inline fun <reified TExpected : Throwable> ThrowableThrown.Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
@JvmName("valueIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <K, V : Any> Assert<Entry<K, V>>.value(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Entry<K, V>>
val <V : Any> Assert<Entry<*, V>>.value: Assert<V>
data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): List<T>

fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
@JvmName("valuesIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <K, V, T : Map<K, V>> Assert<T>.values(assertionCreator: Assert<Collection<V>>.() -> Unit): AssertionPlant<T>
val <V> Assert<Map<*, V>>.values: Assert<Collection<V>>
class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

package ch.tutteli.atrium.api.cc.en_GB.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>

package ch.tutteli.atrium.api.cc.en_GB.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

package ch.tutteli.atrium.api.cc.en_UK

val <T : Any> AssertionPlant<T>.and: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> atLeast(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atLeast(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> atMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> butAtMost(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> butAtMost(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
object CharSequenceContainsSearchersKt

@JvmStatic fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> values(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>

val <T : CharSequence> Assert<T>.contains: CharSequenceContains.Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.contains(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.contains(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsDefaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
val <T : CharSequence> Assert<T>.containsNot: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.containsNot(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsNotDefaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNulllable(plant: Assert<T>, assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.defaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
@JvmName("defaultTranslationOfIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.defaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> exactly(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> exactly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
fun <T : CharSequence> getContains(plant: Assert<T>): CharSequenceContainsBuilder<T, NoOpSearchBehaviour>
fun <T : CharSequence> getContainsNot(plant: Assert<T>): CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>
fun <T : CharSequence> getIgnoringCase(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> getIgnoringCase(builder: CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> getInAnyOrder(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> getInOrder(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
val <T : CharSequence> CharSequenceContains.Builder<T, NoOpSearchBehaviour>.ignoringCase: CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoringCase: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inAnyOrder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inOrder: IterableContains.Builder<E, T, InOrderSearchBehaviour>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
inline fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> Assert<T>.isEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
fun Assert<Boolean>.isFalse(): AssertionPlant<Boolean>
fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.isNotNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isNotSame(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.isNull(): Unit
fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isSame(expected: T): AssertionPlant<T>
fun Assert<Boolean>.isTrue(): AssertionPlant<Boolean>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> notOrAtMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> notOrAtMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?, vararg otherAssertionCreators: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>.only: IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderSearchBehaviour>.only: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
@JvmName("regexIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
fun Assert<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): AssertionPlant<Double>
fun Assert<BigDecimal>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): AssertionPlant<BigDecimal>
inline fun <reified TExpected : Throwable> ThrowableThrown.Builder.toThrow(): Unit
inline fun <reified TExpected : Throwable> ThrowableThrown.Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
@JvmName("valueIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
@JvmName("valuesIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>

package ch.tutteli.atrium.api.cc.en_UK.assertions.charsequence.contains.builders

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

package ch.tutteli.atrium.api.cc.en_UK.assertions.iterable.contains.builders

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

package ch.tutteli.atrium.api.cc.en_UK.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>

NotCheckerOptionImpl(containsBuilder: CharSequenceContains.Builder<T, S>)

interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

package ch.tutteli.atrium.api.cc.en_UK.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<E, T, S>, containsBuilder: IterableContains.Builder<E, T, S>)

interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>

NotCheckerOptionImpl(containsBuilder: IterableContains.Builder<E, T, S>)

interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

package ch.tutteli.atrium.api.cc.infix.en_GB

infix fun <E : Any, T : Iterable<E?>> Assert<T>.all(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.all(nullableEntry: NullableEntry<E>): AssertionPlant<T>
class All<out T> : VarArgHelper<T>

All(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>

infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderSearchBehaviour>.and(only: only): IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.any(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.any(nullableEntry: NullableEntry<E>): AssertionPlant<T>
fun <K, V> Assert<Map<out K, V>>.asEntries(): Assert<Set<Entry<K, V>>>
infix fun <K, V> Assert<Map<out K, V>>.asEntries(assertionCreator: Assert<Set<Entry<K, V>>>.() -> Unit): Assert<Set<Entry<K, V>>>
fun <E> Assert<Array<out E>>.asIterable(): Assert<Iterable<E>>
infix fun <E> Assert<Array<out E>>.asIterable(assertionCreator: Assert<Iterable<E>>.() -> Unit): Assert<Iterable<E>>
@JvmName("byteArrAsIterable") fun Assert<ByteArray>.asIterable(): Assert<Iterable<Byte>>
@JvmName("byteArrAsIterable") infix fun Assert<ByteArray>.asIterable(assertionCreator: Assert<Iterable<Byte>>.() -> Unit): Assert<Iterable<Byte>>
@JvmName("charArrAsIterable") fun Assert<CharArray>.asIterable(): Assert<Iterable<Char>>
@JvmName("charArrAsIterable") infix fun Assert<CharArray>.asIterable(assertionCreator: Assert<Iterable<Char>>.() -> Unit): Assert<Iterable<Char>>
@JvmName("shortArrAsIterable") fun Assert<ShortArray>.asIterable(): Assert<Iterable<Short>>
@JvmName("shortArrAsIterable") infix fun Assert<ShortArray>.asIterable(assertionCreator: Assert<Iterable<Short>>.() -> Unit): Assert<Iterable<Short>>
@JvmName("intArrAsIterable") fun Assert<IntArray>.asIterable(): Assert<Iterable<Int>>
@JvmName("intArrAsIterable") infix fun Assert<IntArray>.asIterable(assertionCreator: Assert<Iterable<Int>>.() -> Unit): Assert<Iterable<Int>>
@JvmName("longArrAsIterable") fun Assert<LongArray>.asIterable(): Assert<Iterable<Long>>
@JvmName("longArrAsIterable") infix fun Assert<LongArray>.asIterable(assertionCreator: Assert<Iterable<Long>>.() -> Unit): Assert<Iterable<Long>>
@JvmName("floatArrAsIterable") fun Assert<FloatArray>.asIterable(): Assert<Iterable<Float>>
@JvmName("floatArrAsIterable") infix fun Assert<FloatArray>.asIterable(assertionCreator: Assert<Iterable<Float>>.() -> Unit): Assert<Iterable<Float>>
@JvmName("doubleArrAsIterable") fun Assert<DoubleArray>.asIterable(): Assert<Iterable<Double>>
@JvmName("doubleArrAsIterable") infix fun Assert<DoubleArray>.asIterable(assertionCreator: Assert<Iterable<Double>>.() -> Unit): Assert<Iterable<Double>>
@JvmName("boolArrAsIterable") fun Assert<BooleanArray>.asIterable(): Assert<Iterable<Boolean>>
@JvmName("boolArrAsIterable") infix fun Assert<BooleanArray>.asIterable(assertionCreator: Assert<Iterable<Boolean>>.() -> Unit): Assert<Iterable<Boolean>>
fun <E> Assert<Sequence<E>>.asIterable(): Assert<Iterable<E>>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
infix fun <T : CharSequence> Assert<T>.contains(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(entries: Entries<E>): AssertionPlant<T>
infix fun <K, V, T : Map<out K, V>> Assert<T>.contains(keyValuePair: Pair<K, V>): AssertionPlant<T>
infix fun <K, V, T : Map<out K, V>> Assert<T>.contains(keyValuePairs: Pairs<K, V>): AssertionPlant<T>
infix fun <K, V : Any, T : Map<out K, V?>> Assert<T>.contains(keyValue: KeyValue<K, V>): AssertionPlant<T>
infix fun <K, V : Any, T : Map<out K, V?>> Assert<T>.contains(keyValues: All<KeyValue<K, V>>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(nullableValue: NullableValue<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsExactly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsExactly(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(entries: Entries<E>): AssertionPlant<T>
infix fun <K> Assert<Map<out K, *>>.containsKey(key: K): AssertionPlant<Map<out K, *>>
infix fun <T : CharSequence> Assert<T>.containsNot(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(values: Values<Any>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(values: Values<E>): AssertionPlant<T>
infix fun <K> Assert<Map<out K, *>>.containsNotKey(key: K): AssertionPlant<Map<out K, *>>
infix fun <T : CharSequence> Assert<T>.containsRegex(pattern: String): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: NullableValue<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictly(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictly(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
class Entries<in T : Any> : GroupWithoutNullableEntries<(Assert<T>.() -> Unit)?>, GroupWithNullableEntries<(Assert<T>.() -> Unit)?>, VarArgHelper<(Assert<T>.() -> Unit)?>

Entries(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
val expected: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
val otherExpected: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

infix fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
class Entry<in T : Any> : GroupWithoutNullableEntries<(Assert<T>.() -> Unit)?>, GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

Entry(assertionCreatorOrNull: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
val <K : Any> Assert<Pair<K, *>>.first: Assert<K>
infix fun <K : Any, V> Assert<Pair<K, V>>.first(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Pair<K, V>>
infix fun <E : Any, T : List<E>> Assert<T>.get(index: Int): AssertionPlant<E>
infix fun <E : Any, T : List<E>> Assert<T>.get(index: Index): ListGetOption<E, T>
infix fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: K): Assert<V>
infix fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: Key<K>): MapGetOption<K, V, T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.grouped(entries: entries): IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
infix fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, NoOpSearchBehaviour>.ignoring(case: case): CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, Group<E>>): AssertionPlant<T>
@JvmName("inAnyOrderEntries") infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<(Assert<E>.() -> Unit)?, Group<(Assert<E>.() -> Unit)?>>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
@JvmName("inAnyOrderNullableValues") fun <E, T : Iterable<E>> inAny(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, order: Order<E, GroupWithNullableEntries<E>>): AssertionPlant<T>
@JvmName("inAnyOrderNullableEntries") fun <E : Any, T : Iterable<E?>> inAny(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>, order: Order<(Assert<E>.() -> Unit)?, GroupWithNullableEntries<(Assert<E>.() -> Unit)?>>): AssertionPlant<T>
data class Index

Index(index: Int)
val index: Int

infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): IterableContains.Builder<E, T, InOrderSearchBehaviour>
inline infix fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
infix fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
infix fun <K : Any, V : Any> Assert<Entry<K, V>>.isKeyValue(keyValuePair: Pair<K, V>): Assert<Entry<K, V>>
infix fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isNotSameAs(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isSameAs(expected: T): AssertionPlant<T>
val <K : Any> Assert<Entry<K, *>>.key: Assert<K>
infix fun <K : Any, V> Assert<Entry<K, V>>.key(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Entry<K, V>>
data class Key<out K>

Key(key: K)
val key: K

data class KeyNullableValue<out K, V : Any>

KeyNullableValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

val <K, V> Assert<Map<out K, V>>.keys: Assert<Set<K>>
infix fun <K, V, T : Map<out K, V>> Assert<T>.keys(assertionCreator: Assert<Set<K>>.() -> Unit): AssertionPlant<T>
data class KeyValue<out K, V : Any>

KeyValue(key: K, valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Assert<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Assert<V>.() -> Unit)?

infix fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
infix fun <T : Throwable> Assert<T>.messageContains(expected: Any): Unit
infix fun <T : Throwable> Assert<T>.messageContains(values: Values<Any>): Unit
infix fun <E : Any, T : Iterable<E?>> Assert<T>.none(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.none(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
infix fun <T : CharSequence> Assert<T>.notTo(contain: contain): NotCheckerOption<T, NotSearchBehaviour>
infix fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.notToBe(keyword: Keyword): Nothing
infix fun <T : CharSequence> Assert<T>.notToBe(Empty: Empty): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.notToBe(Blank: Blank): AssertionPlant<T>
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
infix fun <T : BigDecimal> AssertionPlantNullable<T?>.notToBeNullBut(expected: T): Nothing
infix fun <T : Any> AssertionPlantNullable<T>.notToBeNullBut(keyword: Keyword): Nothing
fun ThrowableThrown.Builder.notToThrow(): Unit
class NullableEntries<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEntries(assertionCreatorOrNull: (Assert<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Assert<T>.() -> Unit)?)
val assertionCreatorOrNull: (Assert<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Assert<T>.() -> Unit)?>
fun toList(): List<(Assert<T>.() -> Unit)?>

class NullableEntry<T : Any> : GroupWithNullableEntries<(Assert<T>.() -> Unit)?>

NullableEntry(assertionCreator: (Assert<T>.() -> Unit)?)
val assertionCreator: (Assert<T>.() -> Unit)?
fun toList(): List<(Assert<T>.() -> Unit)?>

infix fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: (Assert<E>.() -> Unit)?): AssertionPlant<T>
data class NullableValue<T> : GroupWithNullableEntries<T>

NullableValue(expected: T)
val expected: T
fun toList(): List<T>

infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
class NullableValues<T> : GroupWithNullableEntries<T>

NullableValues(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

inline val <T : Any> Assert<T>.o: Assert<T>
class Order<out T, out G : Group<T>>

Order(firstGroup: G, secondGroup: G, vararg otherExpectedGroups: G)
val firstGroup: G
vararg val otherExpectedGroups: Array<out G>
val secondGroup: G

class Pairs<out K, out V> : VarArgHelper<Pair<K, V>>

Pairs(expected: Pair<K, V>, vararg otherExpected: Pair<K, V>)
val expected: Pair<K, V>
vararg val otherExpected: Array<out Pair<K, V>>

fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
class RegexPatterns : VarArgHelper<String>

RegexPatterns(pattern: String, vararg otherPatterns: String)
val expected: String
val otherExpected: Array<out String>

fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf") fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
val <V : Any> Assert<Pair<*, V>>.second: Assert<V>
infix fun <K, V : Any> Assert<Pair<K, V>>.second(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Pair<K, V>>
val Assert<Collection<*>>.size: Assert<Int>
infix fun <E, T : Collection<E>> Assert<T>.size(assertionCreator: Assert<Int>.() -> Unit): Assert<T>
infix fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
@JvmName("valuesIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.to(contain: contain): CharSequenceContains.Builder<T, NoOpSearchBehaviour>
infix fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.toBe(keyword: Keyword): Nothing
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.toBe(expected: T?): Unit
infix fun <T : CharSequence> Assert<T>.toBe(Empty: Empty): AssertionPlant<T>
fun <T> toBe(plant: AssertionPlantNullable<T>, void: Void?): Unit
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.toBeNullIfNullGivenElse(noinline assertionCreatorOrNull: (Assert<T>.() -> Unit)?): Unit
inline infix fun <reified TExpected : Throwable> ThrowableThrown.Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
@JvmName("valueIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <K, V : Any> Assert<Entry<K, V>>.value(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Entry<K, V>>
val <V : Any> Assert<Entry<*, V>>.value: Assert<V>
data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): List<T>

val <K, V> Assert<Map<out K, V>>.values: Assert<Collection<V>>
infix fun <K, V, T : Map<out K, V>> Assert<T>.values(assertionCreator: Assert<Collection<V>>.() -> Unit): AssertionPlant<T>
class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within(group: group): IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

package ch.tutteli.atrium.api.cc.infix.en_GB.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>

package ch.tutteli.atrium.api.cc.infix.en_GB.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

package ch.tutteli.atrium.api.cc.infix.en_GB.creating.list.get.builders

interface ListGetNullableOption<E, T : List<E>>

abstract infix fun assertIt(assertionCreator: AssertionPlantNullable<E>.() -> Unit): Assert<T>
fun <E, T : List<E>> create(plant: Assert<T>, index: Int): ListGetNullableOption<E, T>
abstract val index: Int
abstract val plant: Assert<T>

interface ListGetOption<E : Any, T : List<E>>

abstract infix fun assertIt(assertionCreator: Assert<E>.() -> Unit): Assert<T>
fun <E : Any, T : List<E>> create(plant: Assert<T>, index: Int): ListGetOption<E, T>
abstract val index: Int
abstract val plant: Assert<T>

package ch.tutteli.atrium.api.cc.infix.en_GB.creating.map.get.builders

interface MapGetNullableOption<K, V, T : Map<out K, V>>

abstract infix fun assertIt(assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assert<T>
fun <K, V, T : Map<out K, V>> create(plant: Assert<T>, key: K): MapGetNullableOption<K, V, T>
abstract val key: K
abstract val plant: Assert<T>

interface MapGetOption<K, V : Any, T : Map<out K, V>>

abstract infix fun assertIt(assertionCreator: Assert<V>.() -> Unit): Assert<T>
fun <K, V : Any, T : Map<out K, V>> create(plant: Assert<T>, key: K): MapGetOption<K, V, T>
abstract val key: K
abstract val plant: Assert<T>

package ch.tutteli.atrium.api.cc.infix.en_GB.keywords

object Blank : Keyword
object case : Keyword
object contain : Keyword
object Empty : Keyword
object entries : Keyword
object group : Keyword
interface Keyword
object only : Keyword
object order : Keyword

package ch.tutteli.atrium.api.cc.infix.en_UK

infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> atLeast(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atLeast(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> atMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
@JvmName("yet") infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderSearchBehaviour>.but(only: only): IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> butAtMost(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> butAtMost(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
object case
object CharSequenceContainsSearchersKt

@JvmStatic fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
@JvmStatic fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>

object contain
infix fun <T : CharSequence> Assert<T>.contains(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(defaultTranslationOf: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsDefaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(defaultTranslationsOf: DefaultTranslationsOf): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(objects: Objects<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsRegex(pattern: String): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>
@JvmName("defaultTranslationOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>
class DefaultTranslationsOf

DefaultTranslationsOf(expected: Translatable, vararg otherExpected: Translatable)
val expected: Translatable
vararg val otherExpected: Array<out Translatable>
fun toList(): List<Translatable>

object Empty
infix fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
class Entries<in T : Any, out A : ((Assert<T>) -> Unit)?>

Entries(assertionCreator: A, vararg otherAssertionCreators: A)
val assertionCreator: A
vararg val otherAssertionCreators: Array<out A>
fun toList(): List<A>

infix fun <E : Any, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> exactly(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> exactly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
infix fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, NoOpSearchBehaviour>.ignoring(case: case): CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> ignoring(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>, case: case): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>.ignoring(case: case): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> inAny(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): IterableContains.Builder<E, T, InOrderSearchBehaviour>
fun <E, T : Iterable<E>> inGiven(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
inline infix fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
infix fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isNotSame(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isSame(expected: T): AssertionPlant<T>
infix fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> notOrAtMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> notOrAtMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
infix fun <T : CharSequence> Assert<T>.notTo(contain: contain): NotCheckerOption<T, NotSearchBehaviour>
infix fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.notToBe(onlyEmptyAllowed: Empty): AssertionPlant<T>
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, entries: Entries<E, (Assert<E>.() -> Unit)?>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: (Assert<E>.() -> Unit)?): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
class Objects<out T>

Objects(values: Values<T>)
Objects(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>

object only
object order
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
class RegexPatterns

RegexPatterns(pattern: String, vararg otherPatterns: String)
vararg val otherPatterns: Array<out String>
val pattern: String
fun toList(): List<String>

fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
infix fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
@JvmName("valuesIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>
@JvmName("defaultTranslationsOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.to(contain: contain): CharSequenceContains.Builder<T, NoOpSearchBehaviour>
infix fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
infix fun <T> AssertionPlantNullable<T>.toBe(null: Nothing?): Unit
infix fun <T : CharSequence> Assert<T>.toBe(Empty: Empty): AssertionPlant<T>
inline fun <reified TExpected : Throwable> ThrowableThrown.Builder.toThrow(): Unit
inline infix fun <reified TExpected : Throwable> ThrowableThrown.Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
@JvmName("valueIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
class Values<out T>

Values(objects: Objects<T>)
Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

package ch.tutteli.atrium.api.cc.infix.en_UK.assertions.charsequence.contains.builders

open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilder(containsBuilder: CharSequenceContains.Builder<T, S>)

open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

fun nameContainsNotValuesFun(): String

package ch.tutteli.atrium.api.cc.infix.en_UK.assertions.iterable.contains.builders

open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtLeastCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsButAtMostCheckerBuilder(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsExactlyCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotCheckerBuilder(containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>

IterableContainsNotOrAtMostCheckerBuilder(times: Int, containsBuilder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>)

package ch.tutteli.atrium.api.cc.infix.en_UK.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>)

interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>

NotCheckerOptionImpl(containsBuilder: CharSequenceContains.Builder<T, S>)

interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>)

package ch.tutteli.atrium.api.cc.infix.en_UK.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>

AtLeastCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>

AtMostCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>

ButAtMostCheckerOptionImpl(times: Int, atLeastBuilder: AtLeastCheckerOption<E, T, S>, containsBuilder: IterableContains.Builder<E, T, S>)

interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>

ExactlyCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>

NotCheckerOptionImpl(containsBuilder: IterableContains.Builder<E, T, S>)

interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>

NotOrAtMostCheckerOptionImpl(times: Int, containsBuilder: IterableContains.Builder<E, T, S>)

package ch.tutteli.atrium.api.fluent.en_GB

fun <E : Any, T : Iterable<E?>> Expect<T>.all(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
inline val <T> Expect<T>.and: Expect<T>
infix fun <T> Expect<T>.and(assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.any(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.asEntries(): Expect<Set<Entry<K, V>>>
fun <K, V, T : Map<out K, V>> Expect<T>.asEntries(assertionCreator: Expect<Set<Entry<K, V>>>.() -> Unit): Expect<T>
fun <E, T : Sequence<E>> Expect<T>.asIterable(): Expect<Iterable<E>>
fun <E, T : Sequence<E>> Expect<T>.asIterable(assertionCreator: Expect<Iterable<E>>.() -> Unit): Expect<T>
fun <E> Expect<out Array<out E>>.asList(): Expect<List<E>>
fun <E> Expect<Array<E>>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<Array<E>>
@JvmName("byteArrAsList") fun Expect<ByteArray>.asList(): Expect<List<Byte>>
@JvmName("byteArrAsList") fun Expect<ByteArray>.asList(assertionCreator: Expect<List<Byte>>.() -> Unit): Expect<ByteArray>
@JvmName("charArrAsList") fun Expect<CharArray>.asList(): Expect<List<Char>>
@JvmName("charArrAsList") fun Expect<CharArray>.asList(assertionCreator: Expect<List<Char>>.() -> Unit): Expect<CharArray>
@JvmName("shortArrAsList") fun Expect<ShortArray>.asList(): Expect<List<Short>>
@JvmName("shortArrAsList") fun Expect<ShortArray>.asList(assertionCreator: Expect<List<Short>>.() -> Unit): Expect<ShortArray>
@JvmName("intArrAsList") fun Expect<IntArray>.asList(): Expect<List<Int>>
@JvmName("intArrAsList") fun Expect<IntArray>.asList(assertionCreator: Expect<List<Int>>.() -> Unit): Expect<IntArray>
@JvmName("longArrAsList") fun Expect<LongArray>.asList(): Expect<List<Long>>
@JvmName("longArrAsList") fun Expect<LongArray>.asList(assertionCreator: Expect<List<Long>>.() -> Unit): Expect<LongArray>
@JvmName("floatArrAsList") fun Expect<FloatArray>.asList(): Expect<List<Float>>
@JvmName("floatArrAsList") fun Expect<FloatArray>.asList(assertionCreator: Expect<List<Float>>.() -> Unit): Expect<FloatArray>
@JvmName("doubleArrAsList") fun Expect<DoubleArray>.asList(): Expect<List<Double>>
@JvmName("doubleArrAsList") fun Expect<DoubleArray>.asList(assertionCreator: Expect<List<Double>>.() -> Unit): Expect<DoubleArray>
@JvmName("boolArrAsList") fun Expect<BooleanArray>.asList(): Expect<List<Boolean>>
@JvmName("boolArrAsList") fun Expect<BooleanArray>.asList(assertionCreator: Expect<List<Boolean>>.() -> Unit): Expect<BooleanArray>
fun <E, T : Iterable<E>> Expect<T>.asList(): Expect<List<E>>
fun <E, T : Iterable<E>> Expect<T>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<T>
fun <T : File> Expect<T>.asPath(): Expect<Path>
fun <T : File> Expect<T>.asPath(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atLeast(times: Int): AtLeastCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atLeast(times: Int): AtLeastCheckerStep<E, T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atMost(times: Int): AtMostCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atMost(times: Int): AtMostCheckerStep<E, T, S>
fun <T> Expect<T>.because(reason: String, assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerStep<T, S>.butAtMost(times: Int): ButAtMostCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> AtLeastCheckerStep<E, T, S>.butAtMost(times: Int): ButAtMostCheckerStep<E, T, S>
inline fun <reified TExpected : Throwable> Expect<out Throwable>.cause(): Expect<TExpected>
inline fun <reified TExpected : Throwable> Expect<out Throwable>.cause(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
val <T : CharSequence> Expect<T>.contains: CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
fun <T : CharSequence> Expect<T>.contains(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.contains(expected: E, vararg otherExpected: E): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.contains(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.contains(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.contains(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.contains(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
inline fun <reified E, T : Iterable<E>> Expect<T>.containsElementsOf(expectedIterableLike: IterableLike): Expect<T>
fun <K, V : Any, T : Map<out K, V?>> Expect<T>.containsEntriesOf(mapLike: MapLike): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.containsExactly(expected: E, vararg otherExpected: E): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.containsExactly(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> Expect<T>.containsExactly(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
inline fun <reified E, T : Iterable<E>> Expect<T>.containsExactlyElementsOf(expectedIterableLike: IterableLike): Expect<T>
fun <K, T : Map<out K, *>> Expect<T>.containsKey(key: K): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.containsNoDuplicates(): Expect<T>
val <T : CharSequence> Expect<T>.containsNot: NotCheckerStep<T, NotSearchBehaviour>
fun <T : CharSequence> Expect<T>.containsNot(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.containsNot(expected: E, vararg otherExpected: E): Expect<T>
fun <K, T : Map<out K, *>> Expect<T>.containsNotKey(key: K): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.containsOnly(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.containsOnly(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
fun <K, V : Any, T : Map<out K, V?>> Expect<T>.containsOnlyEntriesOf(mapLike: MapLike): Expect<T>
fun <T : CharSequence> Expect<T>.containsRegex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> Expect<T>.containsRegex(pattern: Regex, vararg otherPatterns: Regex): Expect<T>
val Expect<LocalDate>.day: Expect<Int>
val Expect<LocalDateTime>.day: Expect<Int>
val Expect<ZonedDateTime>.day: Expect<Int>
fun Expect<LocalDate>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
fun Expect<LocalDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
fun Expect<ZonedDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
val Expect<LocalDate>.dayOfWeek: Expect<DayOfWeek>
val Expect<LocalDateTime>.dayOfWeek: Expect<DayOfWeek>
val Expect<ZonedDateTime>.dayOfWeek: Expect<DayOfWeek>
fun Expect<LocalDate>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDate>
fun Expect<LocalDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDateTime>
fun Expect<ZonedDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<ZonedDateTime>
fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.elementsOf(expectedIterable: Iterable<CharSequenceOrNumberOrChar>): Expect<T>
@JvmName("elementsOfIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterable: Iterable<CharSequenceOrNumberOrChar>): Expect<T>
@JvmName("elementsOfIgnoringCase") fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterable: Iterable<CharSequenceOrNumberOrChar>): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline fun <reified E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.elementsOf(expectedIterable: Iterable<E>): Expect<T>
inline fun <reified E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline fun <reified E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterable: Iterable<E>): Expect<T>
inline fun <reified E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline fun <reified E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterable: Iterable<E>): Expect<T>
inline fun <reified E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline fun <reified E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline fun <reified E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline fun <reified E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
fun <T : CharSequence> Expect<T>.endsNotWith(expected: CharSequence): Expect<T>
fun <T : CharSequence> Expect<T>.endsNotWith(expected: Char): Expect<T>
fun <T : Path> Expect<T>.endsNotWith(expected: Path): Expect<T>
fun <T : CharSequence> Expect<T>.endsWith(expected: CharSequence): Expect<T>
fun <T : CharSequence> Expect<T>.endsWith(expected: Char): Expect<T>
fun <T : Path> Expect<T>.endsWith(expected: Path): Expect<T>
fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: (Expect<E>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<E>.() -> Unit)?): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entries(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.entries(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entries(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.entries(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entries(keyValuePair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.entries(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): Expect<T>
class Entries<T : Any> : GroupWithoutNullableEntries<(Expect<T>.() -> Unit)?>, GroupWithNullableEntries<(Expect<T>.() -> Unit)?>, VarArgHelper<(Expect<T>.() -> Unit)?>

Entries(assertionCreatorOrNull: (Expect<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<T>.() -> Unit)?)
val assertionCreatorOrNull: (Expect<T>.() -> Unit)?
val expected: (Expect<T>.() -> Unit)?
vararg val otherAssertionCreatorsOrNulls: Array<(Expect<T>.() -> Unit)?>
val otherExpected: Array<(Expect<T>.() -> Unit)?>
fun toList(): List<(Expect<T>.() -> Unit)?>

fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.entry(keyValue: KeyValue<K, V>): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.entry(keyValue: KeyValue<K, V>): Expect<T>
fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.entry(keyValue: KeyValue<K, V>): Expect<T>
class Entry<T : Any> : GroupWithoutNullableEntries<(Expect<T>.() -> Unit)?>, GroupWithNullableEntries<(Expect<T>.() -> Unit)?>

Entry(assertionCreatorOrNull: (Expect<T>.() -> Unit)?)
val assertionCreatorOrNull: (Expect<T>.() -> Unit)?
fun toList(): List<(Expect<T>.() -> Unit)?>

fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.exactly(times: Int): ExactlyCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.exactly(times: Int): ExactlyCheckerStep<E, T, S>
fun <T : Path> Expect<T>.exists(): Expect<T>
fun <T : Path> Expect<T>.existsNot(): Expect<T>
@Target([AnnotationTarget.FUNCTION]) annotation class ExperimentalWithOptions

ExperimentalWithOptions()

val <T : Path> Expect<T>.extension: Expect<String>
fun <T : Path> Expect<T>.extension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.feature(property: KProperty1<in T, R>): FeatureExpect<T, R>
fun <T, R> Expect<T>.feature(property: KProperty1<in T, R>, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.feature(f: KFunction1<T, R>): FeatureExpect<T, R>
fun <T, R> Expect<T>.feature(f: KFunction1<T, R>, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, R> Expect<T>.feature(f: KFunction2<T, A1, R>, a1: A1): FeatureExpect<T, R>
fun <T, A1, R> Expect<T>.feature(f: KFunction2<T, A1, R>, a1: A1, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, A2, R> Expect<T>.feature(f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExpect<T, R>
fun <T, A1, A2, R> Expect<T>.feature(f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, A2, A3, R> Expect<T>.feature(f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExpect<T, R>
fun <T, A1, A2, A3, R> Expect<T>.feature(f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, A2, A3, A4, R> Expect<T>.feature(f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExpect<T, R>
fun <T, A1, A2, A3, A4, R> Expect<T>.feature(f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, A1, A2, A3, A4, A5, R> Expect<T>.feature(f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExpect<T, R>
fun <T, A1, A2, A3, A4, A5, R> Expect<T>.feature(f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.feature(description: String, provider: T.() -> R): FeatureExpect<T, R>
fun <T, R> Expect<T>.feature(description: String, provider: T.() -> R, assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.feature(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>): FeatureExpect<T, R>
fun <T, R> Expect<T>.feature(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>, assertionCreator: Expect<R>.() -> Unit): Expect<T>
val <T : Path> Expect<T>.fileName: Expect<String>
fun <T : Path> Expect<T>.fileName(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <T : Path> Expect<T>.fileNameWithoutExtension: Expect<String>
fun <T : Path> Expect<T>.fileNameWithoutExtension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <K, T : Pair<K, *>> Expect<T>.first: Expect<K>
fun <K, V, T : Pair<K, V>> Expect<T>.first(assertionCreator: Expect<K>.() -> Unit): Expect<T>
fun <E, T : List<E>> Expect<T>.get(index: Int): Expect<E>
fun <E, T : List<E>> Expect<T>.get(index: Int, assertionCreator: Expect<E>.() -> Unit): Expect<T>
fun <T : CharSequence> getContains(expect: Expect<T>): CharSequenceContains.Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> getContainsNot(expect: Expect<T>): NotCheckerOption<T, NotSearchBehaviour>
fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: K): Expect<V>
fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: K, assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.grouped: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.grouped: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>
fun <T : Path> Expect<T>.hasDirectoryEntry(entry: String, vararg otherEntries: String): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.hasNext(): Expect<T>
fun <E, T : Iterable<E>> Expect<T>.hasNotNext(): Expect<T>
fun <T : Path> Expect<T>.hasSameBinaryContentAs(targetPath: Path): Expect<T>
fun <T : Path> Expect<T>.hasSameTextualContentAs(targetPath: Path, sourceCharset: Charset = Charsets.UTF_8, targetCharset: Charset = Charsets.UTF_8): Expect<T>
fun <T : Collection<*>> Expect<T>.hasSize(expected: Int): Expect<T>
val <T : CharSequence> CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>.ignoringCase: CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerStep<T, NotSearchBehaviour>.ignoringCase: NotCheckerStep<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> CharSequenceContains.Builder<T, NoOpSearchBehaviour>.ignoringCase: CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoringCase: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): Expect<T>
@JvmName("inAnyOrderEntries") fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<(Expect<E>.() -> Unit)?>, secondGroup: Group<(Expect<E>.() -> Unit)?>, vararg otherExpectedGroups: Group<(Expect<E>.() -> Unit)?>): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): Expect<T>
@JvmName("inAnyOrderEntries") fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<(Expect<E>.() -> Unit)?>, secondGroup: Group<(Expect<E>.() -> Unit)?>, vararg otherExpectedGroups: Group<(Expect<E>.() -> Unit)?>): Expect<T>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inAnyOrder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inAnyOrder: IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inAnyOrder: MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inOrder: IterableContains.Builder<E, T, InOrderSearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inOrder: IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inOrder: MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>
inline fun <reified TSub : Any> Expect<*>.isA(): Expect<TSub>
inline fun <reified TSub : Any> Expect<*>.isA(noinline assertionCreator: Expect<TSub>.() -> Unit): Expect<TSub>
fun <T : Path> Expect<T>.isAbsolute(): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfter(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfter(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfterOrEqual(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfterOrEqual(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBefore(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBefore(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBeforeOrEqual(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : Path> Expect<T>.isDirectory(): Expect<T>
fun <T : CharSequence> Expect<T>.isEmpty(): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isEqual(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isEqual(expected: String): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : Comparable<T>> Expect<T>.isEqualComparingTo(expected: T): Expect<T>
fun <T : BigDecimal> Expect<T>.isEqualIncludingScale(expected: T): Expect<T>
fun <T : Path> Expect<T>.isExecutable(): Expect<T>
fun <T : Comparable<T>> Expect<T>.isGreaterThan(expected: T): Expect<T>
fun <T : Comparable<T>> Expect<T>.isGreaterThanOrEqual(expected: T): Expect<T>
fun <K, V, T : Entry<K, V>> Expect<T>.isKeyValue(key: K, value: V): Expect<T>
fun <T : Comparable<T>> Expect<T>.isLessThan(expected: T): Expect<T>
fun <T : Comparable<T>> Expect<T>.isLessThanOrEqual(expected: T): Expect<T>
fun <T> Expect<T>.isNoneOf(expected: T, vararg otherValues: T): Expect<T>
fun <T : CharSequence> Expect<T>.isNotBlank(): Expect<T>
fun <T : CharSequence> Expect<T>.isNotEmpty(): Expect<T>
fun <T : BigDecimal> Expect<T>.isNotEqualIncludingScale(expected: T): Expect<T>
inline fun <reified T> Expect<T>.isNotIn(expected: IterableLike): Expect<T>
fun <T : BigDecimal> Expect<T>.isNotNumericallyEqualTo(expected: T): Expect<T>
fun <T> Expect<T>.isNotSameAs(expected: T): Expect<T>
fun <T : BigDecimal> Expect<T>.isNumericallyEqualTo(expected: T): Expect<T>
fun <E, T : Optional<E>> Expect<T>.isPresent(): Expect<E>
fun <E, T : Optional<E>> Expect<T>.isPresent(assertionCreator: Expect<E>.() -> Unit): Expect<T>
fun <T : Path> Expect<T>.isReadable(): Expect<T>
fun <T : Path> Expect<T>.isRegularFile(): Expect<T>
fun <T : Path> Expect<T>.isRelative(): Expect<T>
fun <T> Expect<T>.isSameAs(expected: T): Expect<T>
fun <T : Path> Expect<T>.isWritable(): Expect<T>
val <K, T : Entry<K, *>> Expect<T>.key: Expect<K>
fun <K, V, T : Entry<K, V>> Expect<T>.key(assertionCreator: Expect<K>.() -> Unit): Expect<T>
val <K, T : Map<out K, *>> Expect<T>.keys: Expect<Set<K>>
fun <K, V, T : Map<out K, V>> Expect<T>.keys(assertionCreator: Expect<Set<K>>.() -> Unit): Expect<T>
data class KeyValue<out K, V : Any>

KeyValue(key: K, valueAssertionCreatorOrNull: (Expect<V>.() -> Unit)?)
val key: K
fun toPair(): Pair<K, (Expect<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Expect<V>.() -> Unit)?

fun <T : CharSequence> Expect<T>.matches(expected: Regex): Expect<T>
fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(): Expect<E>
fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(assertionCreator: Expect<E>.() -> Unit): Expect<T>
val <T : Throwable> Expect<T>.message: Expect<String>
fun <T : Throwable> Expect<T>.message(assertionCreator: Expect<String>.() -> Unit): Expect<T>
fun <T : Throwable> Expect<T>.messageContains(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(): Expect<E>
fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(assertionCreator: Expect<E>.() -> Unit): Expect<T>
fun <T : CharSequence> Expect<T>.mismatches(expected: Regex): Expect<T>
val Expect<LocalDate>.month: Expect<Int>
val Expect<LocalDateTime>.month: Expect<Int>
val Expect<ZonedDateTime>.month: Expect<Int>
fun Expect<LocalDate>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
fun Expect<LocalDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
fun Expect<ZonedDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
fun <E : Any, T : Iterable<E?>> Expect<T>.none(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<E, T, S>
fun <T> Expect<T>.notToBe(expected: T): Expect<T>
inline fun <reified T : Any> Expect<T?>.notToBeNull(): Expect<T>
inline fun <reified T : Any> Expect<T?>.notToBeNull(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <R, T : () -> R> Expect<T>.notToThrow(): Expect<R>
fun <R, T : () -> R> Expect<T>.notToThrow(assertionCreator: Expect<R>.() -> Unit): Expect<R>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>.only: IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderSearchBehaviour>.only: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>.only: IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>.only: IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.only: MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>.only: MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>
val <T : Path> Expect<T>.parent: Expect<Path>
fun <T : Path> Expect<T>.parent(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.regex(pattern: Regex, vararg otherPatterns: Regex): Expect<T>
@JvmName("regexIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: Regex, vararg otherPatterns: Regex): Expect<T>
@JvmName("regexIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): Expect<T>
fun <T : Path> Expect<T>.resolve(other: String): Expect<Path>
fun <T : Path> Expect<T>.resolve(other: String, assertionCreator: Expect<Path>.() -> Unit): Expect<T>
val <V, T : Pair<*, V>> Expect<T>.second: Expect<V>
fun <K, V, T : Pair<K, V>> Expect<T>.second(assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <T : Collection<*>> Expect<T>.size: Expect<Int>
fun <E, T : Collection<E>> Expect<T>.size(assertionCreator: Expect<Int>.() -> Unit): Expect<T>
fun <T : CharSequence> Expect<T>.startsNotWith(expected: CharSequence): Expect<T>
fun <T : CharSequence> Expect<T>.startsNotWith(expected: Char): Expect<T>
fun <T : Path> Expect<T>.startsNotWith(expected: Path): Expect<T>
fun <T : CharSequence> Expect<T>.startsWith(expected: CharSequence): Expect<T>
fun <T : CharSequence> Expect<T>.startsWith(expected: Char): Expect<T>
fun <T : Path> Expect<T>.startsWith(expected: Path): Expect<T>
fun <T> Expect<T>.toBe(expected: T): Expect<T>
@JvmName("toBeNull") fun <T : BigDecimal> Expect<T?>.toBe(expected: Nothing?): Expect<T?>
fun <T : Any> Expect<T?>.toBeNullIfNullGivenElse(assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Expect<T?>
fun Expect<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): Expect<Float>
fun Expect<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): Expect<Double>
fun <T : BigDecimal> Expect<T>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): Expect<T>
inline fun <reified TExpected : Throwable> Expect<() -> Any?>.toThrow(): Expect<TExpected>
inline fun <reified TExpected : Throwable> Expect<() -> Any?>.toThrow(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
@JvmName("valueIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
@JvmName("valueIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): Expect<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
fun <E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.value(expected: E): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
fun <K, V, T : Entry<K, V>> Expect<T>.value(assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <V, T : Entry<*, V>> Expect<T>.value: Expect<V>
data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

Value(expected: T)
val expected: T
fun toList(): List<T>

fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
@JvmName("valuesIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
@JvmName("valuesIgnoringCase") fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.values(expected: CharSequenceOrNumberOrChar, vararg otherExpected: CharSequenceOrNumberOrChar): Expect<T>
fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): Expect<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): Expect<T>
fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): Expect<T>
fun <E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): Expect<T>
fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): Expect<T>
fun <K, V, T : Map<out K, V>> Expect<T>.values(assertionCreator: Expect<Collection<V>>.() -> Unit): Expect<T>
val <V, T : Map<*, V>> Expect<T>.values: Expect<Collection<V>>
class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

Values(expected: T, vararg otherExpected: T)
val expected: T
vararg val otherExpected: Array<out T>
fun toList(): List<T>

val <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within: IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>.within: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
fun <T> RootExpect<T>.withOptions(configuration: ExpectBuilder.OptionsChooser<T>.() -> Unit): Expect<T>
fun <T> RootExpect<T>.withOptions(options: ExpectOptions<T>): Expect<T>
fun <T, R> FeatureExpect<T, R>.withOptions(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): Expect<R>
fun <T, R> FeatureExpect<T, R>.withOptions(options: FeatureExpectOptions<R>): Expect<R>
fun <T> RootExpect<T>.withRepresentation(textRepresentation: String): Expect<T>
fun <T> RootExpect<T>.withRepresentation(representationProvider: (T) -> Any): Expect<T>
fun <T, R> FeatureExpect<T, R>.withRepresentation(textRepresentation: String): Expect<R>
fun <T, R> FeatureExpect<T, R>.withRepresentation(representationProvider: (R) -> Any): Expect<R>
val Expect<LocalDate>.year: Expect<Int>
val Expect<LocalDateTime>.year: Expect<Int>
val Expect<ZonedDateTime>.year: Expect<Int>
fun Expect<LocalDate>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
fun Expect<LocalDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
fun Expect<ZonedDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>

package ch.tutteli.atrium.api.fluent.en_GB.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>

package ch.tutteli.atrium.api.fluent.en_GB.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

package ch.tutteli.atrium.api.fluent.en_GB.jdk8

fun <T : File> Expect<T>.asPath(): Expect<Path>
fun <T : File> Expect<T>.asPath(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
val <T : LocalDate> Expect<T>.day: Expect<Int>
fun <T : LocalDate> Expect<T>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<T>
val <T : LocalDate> Expect<T>.dayOfWeek: Expect<DayOfWeek>
fun <T : LocalDate> Expect<T>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<T>
fun <T : Path> Expect<T>.endsNotWith(expected: Path): Expect<T>
fun <T : Path> Expect<T>.endsWith(expected: Path): Expect<T>
fun <T : Path> Expect<T>.exists(): Expect<T>
fun <T : Path> Expect<T>.existsNot(): Expect<T>
val <T : Path> Expect<T>.extension: Expect<String>
fun <T : Path> Expect<T>.extension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <T : Path> Expect<T>.fileName: Expect<String>
fun <T : Path> Expect<T>.fileName(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <T : Path> Expect<T>.fileNameWithoutExtension: Expect<String>
fun <T : Path> Expect<T>.fileNameWithoutExtension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
fun <T : Path> Expect<T>.hasSameBinaryContentAs(targetPath: Path): Expect<T>
fun <T : Path> Expect<T>.hasSameTextualContentAs(targetPath: Path, sourceCharset: Charset = Charsets.UTF_8, targetCharset: Charset = Charsets.UTF_8): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfter(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isAfterOrEqual(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBefore(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
fun <T : Path> Expect<T>.isDirectory(): Expect<T>
fun <T : Optional<*>> Expect<T>.isEmpty(): Expect<T>
fun <T : ChronoLocalDate> Expect<T>.isEqual(expected: ChronoLocalDate): Expect<T>
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoLocalDateTime<*>): Expect<T>
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoZonedDateTime<*>): Expect<T>
fun <E, T : Optional<E>> Expect<T>.isPresent(): Expect<E>
fun <E, T : Optional<E>> Expect<T>.isPresent(assertionCreator: Expect<E>.() -> Unit): Expect<T>
fun <T : Path> Expect<T>.isReadable(): Expect<T>
fun <T : Path> Expect<T>.isRegularFile(): Expect<T>
fun <T : Path> Expect<T>.isWritable(): Expect<T>
val <T : LocalDate> Expect<T>.month: Expect<Int>
fun <T : LocalDate> Expect<T>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<T>
val <T : Path> Expect<T>.parent: Expect<Path>
fun <T : Path> Expect<T>.parent(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
fun <T : Path> Expect<T>.resolve(other: String): Expect<Path>
fun <T : Path> Expect<T>.resolve(other: String, assertionCreator: Expect<Path>.() -> Unit): Expect<T>
fun <T : Path> Expect<T>.startsNotWith(expected: Path): Expect<T>
fun <T : Path> Expect<T>.startsWith(expected: Path): Expect<T>
val <T : LocalDate> Expect<T>.year: Expect<Int>
fun <T : LocalDate> Expect<T>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<T>

package ch.tutteli.atrium.api.fluent.en_GB.kotlin_1_3

inline fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(): Expect<TExpected>
inline fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
fun <E, T : Result<E>> Expect<T>.isSuccess(): Expect<E>
fun <E, T : Result<E>> Expect<T>.isSuccess(assertionCreator: Expect<E>.() -> Unit): Expect<T>

package ch.tutteli.atrium.api.infix.en_GB

object absolute : Keyword
object aDirectory : Keyword
fun <T> all(t: T, vararg ts: T): All<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.all(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
inline infix fun <T> Expect<T>.and(o: o): Expect<T>
infix fun <T> Expect<T>.and(assertionCreator: Expect<T>.() -> Unit): Expect<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderSearchBehaviour>.and(only: only): IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>.and(only: only): IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>.and(only: only): MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.any(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
object aRegularFile : Keyword
infix fun <K, V, T : Map<out K, V>> Expect<T>.asEntries(o: o): Expect<Set<Entry<K, V>>>
infix fun <K, V, T : Map<out K, V>> Expect<T>.asEntries(assertionCreator: Expect<Set<Entry<K, V>>>.() -> Unit): Expect<T>
infix fun <E, T : Sequence<E>> Expect<T>.asIterable(o: o): Expect<Iterable<E>>
infix fun <E, T : Sequence<E>> Expect<T>.asIterable(assertionCreator: Expect<Iterable<E>>.() -> Unit): Expect<T>
infix fun <E> Expect<out Array<out E>>.asList(o: o): Expect<List<E>>
infix fun <E> Expect<Array<E>>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<Array<E>>
@JvmName("byteArrAsList") infix fun Expect<ByteArray>.asList(o: o): Expect<List<Byte>>
@JvmName("byteArrAsList") infix fun Expect<ByteArray>.asList(assertionCreator: Expect<List<Byte>>.() -> Unit): Expect<ByteArray>
@JvmName("charArrAsList") infix fun Expect<CharArray>.asList(o: o): Expect<List<Char>>
@JvmName("charArrAsList") infix fun Expect<CharArray>.asList(assertionCreator: Expect<List<Char>>.() -> Unit): Expect<CharArray>
@JvmName("shortArrAsList") infix fun Expect<ShortArray>.asList(o: o): Expect<List<Short>>
@JvmName("shortArrAsList") infix fun Expect<ShortArray>.asList(assertionCreator: Expect<List<Short>>.() -> Unit): Expect<ShortArray>
@JvmName("intArrAsList") infix fun Expect<IntArray>.asList(o: o): Expect<List<Int>>
@JvmName("intArrAsList") infix fun Expect<IntArray>.asList(assertionCreator: Expect<List<Int>>.() -> Unit): Expect<IntArray>
@JvmName("longArrAsList") infix fun Expect<LongArray>.asList(o: o): Expect<List<Long>>
@JvmName("longArrAsList") infix fun Expect<LongArray>.asList(assertionCreator: Expect<List<Long>>.() -> Unit): Expect<LongArray>
@JvmName("floatArrAsList") infix fun Expect<FloatArray>.asList(o: o): Expect<List<Float>>
@JvmName("floatArrAsList") infix fun Expect<FloatArray>.asList(assertionCreator: Expect<List<Float>>.() -> Unit): Expect<FloatArray>
@JvmName("doubleArrAsList") infix fun Expect<DoubleArray>.asList(o: o): Expect<List<Double>>
@JvmName("doubleArrAsList") infix fun Expect<DoubleArray>.asList(assertionCreator: Expect<List<Double>>.() -> Unit): Expect<DoubleArray>
@JvmName("boolArrAsList") infix fun Expect<BooleanArray>.asList(o: o): Expect<List<Boolean>>
@JvmName("boolArrAsList") infix fun Expect<BooleanArray>.asList(assertionCreator: Expect<List<Boolean>>.() -> Unit): Expect<BooleanArray>
infix fun <E, T : Iterable<E>> Expect<T>.asList(o: o): Expect<List<E>>
infix fun <E, T : Iterable<E>> Expect<T>.asList(assertionCreator: Expect<List<E>>.() -> Unit): Expect<T>
infix fun <T : File> Expect<T>.asPath(o: o): Expect<Path>
infix fun <T : File> Expect<T>.asPath(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atLeast(times: Int): AtLeastCheckerStep<T, S>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atLeast(times: Int): AtLeastCheckerStep<E, T, S>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.atMost(times: Int): AtMostCheckerStep<T, S>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.atMost(times: Int): AtMostCheckerStep<E, T, S>
infix fun <T> Expect<T>.because(keyWithCreator: KeyWithCreator<String, T>): Expect<T>
object blank : Keyword
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>.but(only: only): IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.but(only: only): MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerStep<T, S>.butAtMost(times: Int): ButAtMostCheckerStep<T, S>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> AtLeastCheckerStep<E, T, S>.butAtMost(times: Int): ButAtMostCheckerStep<E, T, S>
object case : Keyword
inline fun <reified TExpected : Throwable> Expect<out Throwable>.cause(): Expect<TExpected>
inline infix fun <reified TExpected : Throwable> Expect<out Throwable>.cause(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
infix fun <T : CharSequence> Expect<T>.contains(o: o): CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
infix fun <T : CharSequence> Expect<T>.contains(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> Expect<T>.contains(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> Expect<T>.contains(pattern: Regex): Expect<T>
infix fun <T : CharSequence> Expect<T>.contains(regexPatterns: RegexPatterns): Expect<T>
infix fun <T : CharSequence> Expect<T>.contains(patterns: All<Regex>): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.contains(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.contains(values: Values<E>): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.contains(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.contains(entries: Entries<E>): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.contains(noDuplicates: noDuplicates): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.contains(keyValuePair: Pair<K, V>): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.contains(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.contains(keyValue: KeyWithValueCreator<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.contains(allKeyValues: KeyValues<K, V>): Expect<T>
inline infix fun <reified E, T : Iterable<E>> Expect<T>.containsElementsOf(expectedIterableLike: IterableLike): Expect<T>
infix fun <K, V : Any, T : Map<out K, V?>> Expect<T>.containsEntriesOf(mapLike: MapLike): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.containsExactly(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.containsExactly(values: Values<E>): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.containsExactly(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> Expect<T>.containsExactly(entries: Entries<E>): Expect<T>
inline infix fun <reified E, T : Iterable<E>> Expect<T>.containsExactlyElementsOf(expectedIterableLike: IterableLike): Expect<T>
infix fun <K, T : Map<out K, *>> Expect<T>.containsKey(key: K): Expect<T>
infix fun <T : CharSequence> Expect<T>.containsNot(o: o): NotCheckerStep<T, NotSearchBehaviour>
infix fun <T : CharSequence> Expect<T>.containsNot(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> Expect<T>.containsNot(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.containsNot(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.containsNot(values: Values<E>): Expect<T>
infix fun <K, T : Map<out K, *>> Expect<T>.containsNotKey(key: K): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.containsOnly(keyValuePair: Pair<K, V>): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.containsOnly(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.containsOnly(keyValue: KeyWithValueCreator<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T : Map<out K, V?>> Expect<T>.containsOnly(allKeyValues: KeyValues<K, V>): Expect<T>
infix fun <K, V : Any, T : Map<out K, V?>> Expect<T>.containsOnlyEntriesOf(mapLike: MapLike): Expect<T>
infix fun <T : CharSequence> Expect<T>.containsRegex(pattern: String): Expect<T>
val Expect<LocalDate>.day: Expect<Int>
val Expect<LocalDateTime>.day: Expect<Int>
val Expect<ZonedDateTime>.day: Expect<Int>
infix fun Expect<LocalDate>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
infix fun Expect<LocalDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
infix fun Expect<ZonedDateTime>.day(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
val Expect<LocalDate>.dayOfWeek: Expect<DayOfWeek>
val Expect<LocalDateTime>.dayOfWeek: Expect<DayOfWeek>
val Expect<ZonedDateTime>.dayOfWeek: Expect<DayOfWeek>
infix fun Expect<LocalDate>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDate>
infix fun Expect<LocalDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<LocalDateTime>
infix fun Expect<ZonedDateTime>.dayOfWeek(assertionCreator: Expect<DayOfWeek>.() -> Unit): Expect<ZonedDateTime>
fun directoryEntries(entry: String, vararg otherEntries: String): DirectoryEntries
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.elementsOf(expectedIterable: Iterable<CharSequenceOrNumberOrChar>): Expect<T>
@JvmName("elementsOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterable: Iterable<CharSequenceOrNumberOrChar>): Expect<T>
@JvmName("elementsOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterable: Iterable<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
@JvmName("elementsOfIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline infix fun <reified E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.elementsOf(expectedIterable: Iterable<E>): Expect<T>
inline infix fun <reified E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline infix fun <reified E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterable: Iterable<E>): Expect<T>
inline infix fun <reified E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline infix fun <reified E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterable: Iterable<E>): Expect<T>
inline infix fun <reified E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline infix fun <reified E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline infix fun <reified E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
inline infix fun <reified E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.elementsOf(expectedIterableLike: IterableLike): Expect<T>
object empty : Keyword
infix fun <T : CharSequence> Expect<T>.endsNotWith(expected: CharSequence): Expect<T>
infix fun <T : CharSequence> Expect<T>.endsNotWith(expected: Char): Expect<T>
infix fun <T : Path> Expect<T>.endsNotWith(expected: Path): Expect<T>
infix fun <T : CharSequence> Expect<T>.endsWith(expected: CharSequence): Expect<T>
infix fun <T : CharSequence> Expect<T>.endsWith(expected: Char): Expect<T>
infix fun <T : Path> Expect<T>.endsWith(expected: Path): Expect<T>
fun <T : Any> entries(assertionCreatorOrNull: (Expect<T>.() -> Unit)?, vararg otherAssertionCreatorsOrNulls: (Expect<T>.() -> Unit)?): Entries<T>
object entries : Keyword
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entriesOf(expectedMapLike: MapLike): Expect<T>
fun <T : Any> entry(assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Entry<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.entry(keyValue: KeyWithValueCreator<K, V>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.entry(keyValue: KeyWithValueCreator<K, V>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.entry(keyValuePair: Pair<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.entry(keyValue: KeyWithValueCreator<K, V>): Expect<T>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.exactly(times: Int): ExactlyCheckerStep<T, S>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.exactly(times: Int): ExactlyCheckerStep<E, T, S>
object executable : Keyword
object existing : Keyword
@Target([AnnotationTarget.FUNCTION]) annotation class ExperimentalWithOptions

ExperimentalWithOptions()

val <T : Path> Expect<T>.extension: Expect<String>
infix fun <T : Path> Expect<T>.extension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
fun <T, R> MetaFeatureOption<T>.f(description: String, provider: R): MetaFeature<R>
infix fun <T, R> Expect<T>.feature(property: KProperty1<in T, R>): FeatureExpect<T, R>
infix fun <T, R> Expect<T>.feature(f: KFunction1<T, R>): FeatureExpect<T, R>
infix fun <T, R> Expect<T>.feature(of: Feature<in T, R>): FeatureExpect<T, R>
infix fun <T, R> Expect<T>.feature(of: FeatureWithCreator<in T, R>): Expect<T>
infix fun <T, R> Expect<T>.feature(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>): FeatureExpect<T, R>
infix fun <T, R> Expect<T>.feature(of: MetaFeatureOptionWithCreator<T, R>): Expect<T>
val <T : Path> Expect<T>.fileName: Expect<String>
infix fun <T : Path> Expect<T>.fileName(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <T : Path> Expect<T>.fileNameWithoutExtension: Expect<String>
infix fun <T : Path> Expect<T>.fileNameWithoutExtension(assertionCreator: Expect<String>.() -> Unit): Expect<T>
val <K, T : Pair<K, *>> Expect<T>.first: Expect<K>
infix fun <K, V, T : Pair<K, V>> Expect<T>.first(assertionCreator: Expect<K>.() -> Unit): Expect<T>
infix fun <E, T : List<E>> Expect<T>.get(index: Int): Expect<E>
infix fun <E, T : List<E>> Expect<T>.get(index: IndexWithCreator<E>): Expect<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: K): Expect<V>
infix fun <K, V, T : Map<out K, V>> Expect<T>.getExisting(key: KeyWithCreator<K, V>): Expect<T>
object group : Keyword
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.grouped(entries: entries): IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.grouped(entries: entries): IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>
infix fun <E, T : Iterable<E>> Expect<T>.has(next: next): Expect<T>
infix fun <T : Path> Expect<T>.has(directoryEntries: DirectoryEntries): Expect<T>
infix fun <T : Path> Expect<T>.hasDirectoryEntry(entry: String): Expect<T>
infix fun <E, T : Iterable<E>> Expect<T>.hasNot(next: next): Expect<T>
infix fun <T : Path> Expect<T>.hasSameBinaryContentAs(targetPath: Path): Expect<T>
infix fun <T : Path> Expect<T>.hasSameTextualContentAs(targetPath: Path): Expect<T>
infix fun <T : Path> Expect<T>.hasSameTextualContentAs(pathWithEncoding: PathWithEncoding): Expect<T>
infix fun <T : Collection<*>> Expect<T>.hasSize(expected: Int): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>.ignoring(case: case): CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerStep<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerStep<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, NoOpSearchBehaviour>.ignoring(case: case): CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, Group<E>>): Expect<T>
@JvmName("inAnyOrderEntries") infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<(Expect<E>.() -> Unit)?, Group<(Expect<E>.() -> Unit)?>>): Expect<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, Group<E>>): Expect<T>
@JvmName("inAnyOrderEntries") infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<(Expect<E>.() -> Unit)?, Group<(Expect<E>.() -> Unit)?>>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inAny(order: order): IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inAny(order: order): MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>
fun <E> index(index: Int, assertionCreator: Expect<E>.() -> Unit): IndexWithCreator<E>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): IterableContains.Builder<E, T, InOrderSearchBehaviour>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>.inGiven(order: order): IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>.inGiven(order: order): MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>
inline fun <reified TSub : Any> Expect<*>.isA(): Expect<TSub>
inline infix fun <reified TSub : Any> Expect<*>.isA(noinline assertionCreator: Expect<TSub>.() -> Unit): Expect<TSub>
infix fun <T : ChronoLocalDate> Expect<T>.isAfter(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isAfter(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfter(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isAfterOrEqual(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isAfterOrEqual(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isAfterOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isBefore(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isBefore(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBefore(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isBeforeOrEqual(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isBeforeOrEqual(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isEqual(expected: ChronoLocalDate): Expect<T>
infix fun <T : ChronoLocalDate> Expect<T>.isEqual(expected: String): Expect<T>
infix fun <T : ChronoLocalDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoLocalDateTime<*>): Expect<T>
infix fun <T : ChronoZonedDateTime<out ChronoLocalDate>> Expect<T>.isEqual(expected: ChronoZonedDateTime<*>): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isEqualComparingTo(expected: T): Expect<T>
infix fun <T : BigDecimal> Expect<T>.isEqualIncludingScale(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isGreaterThan(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isGreaterThanOrEqual(expected: T): Expect<T>
infix fun <K, V, T : Entry<K, V>> Expect<T>.isKeyValue(keyValuePair: Pair<K, V>): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isLessThan(expected: T): Expect<T>
infix fun <T : Comparable<T>> Expect<T>.isLessThanOrEqual(expected: T): Expect<T>
infix fun <T> Expect<T>.isNoneOf(values: Values<T>): Expect<T>
infix fun <T : BigDecimal> Expect<T>.isNotEqualIncludingScale(expected: T): Expect<T>
inline infix fun <reified T> Expect<T>.isNotIn(expected: IterableLike): Expect<T>
infix fun <T : BigDecimal> Expect<T>.isNotNumericallyEqualTo(expected: T): Expect<T>
infix fun <T> Expect<T>.isNotSameAs(expected: T): Expect<T>
infix fun <T : BigDecimal> Expect<T>.isNumericallyEqualTo(expected: T): Expect<T>
infix fun <T> Expect<T>.isSameAs(expected: T): Expect<T>
inline val <T> Expect<T>.it: Expect<T>
inline val <T> Expect<T>.its: Expect<T>
fun <K, V> key(key: K, assertionCreator: Expect<V>.() -> Unit): KeyWithCreator<K, V>
infix fun <K, V, T : Entry<K, V>> Expect<T>.key(assertionCreator: Expect<K>.() -> Unit): Expect<T>
val <K, T : Entry<K, *>> Expect<T>.key: Expect<K>
val <K, T : Map<out K, *>> Expect<T>.keys: Expect<Set<K>>
infix fun <K, V, T : Map<out K, V>> Expect<T>.keys(assertionCreator: Expect<Set<K>>.() -> Unit): Expect<T>
fun <K, V : Any> keyValue(key: K, valueAssertionCreatorOrNull: (Expect<V>.() -> Unit)?): KeyWithValueCreator<K, V>
fun <K, V : Any> keyValues(keyValue: KeyWithValueCreator<K, V>, vararg otherKeyValues: KeyWithValueCreator<K, V>): KeyValues<K, V>
interface Keyword
infix fun <T : CharSequence> Expect<T>.matches(expected: Regex): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.matchFor(pattern: Regex): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.matchFor(patterns: All<Regex>): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.matchFor(pattern: Regex): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.matchFor(patterns: All<Regex>): Expect<T>
infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(o: o): Expect<E>
infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.max(assertionCreator: Expect<E>.() -> Unit): Expect<T>
val <T : Throwable> Expect<T>.message: Expect<String>
infix fun <T : Throwable> Expect<T>.message(assertionCreator: Expect<String>.() -> Unit): Expect<T>
infix fun <T : Throwable> Expect<T>.messageContains(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : Throwable> Expect<T>.messageContains(values: Values<Any>): Expect<T>
infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(o: o): Expect<E>
infix fun <E : Comparable<E>, T : Iterable<E>> Expect<T>.min(assertionCreator: Expect<E>.() -> Unit): Expect<T>
infix fun <T : CharSequence> Expect<T>.mismatches(expected: Regex): Expect<T>
val Expect<LocalDate>.month: Expect<Int>
val Expect<LocalDateTime>.month: Expect<Int>
val Expect<ZonedDateTime>.month: Expect<Int>
infix fun Expect<LocalDate>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
infix fun Expect<LocalDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
infix fun Expect<ZonedDateTime>.month(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>
object next : Keyword
object noDuplicates : Keyword
infix fun <E : Any, T : Iterable<E?>> Expect<T>.none(assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Expect<T>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<T, S>
infix fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> IterableContains.Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
infix fun <E, T, S : InAnyOrderSearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerStep<E, T, S>
infix fun <T> Expect<T>.notToBe(expected: T): Expect<T>
infix fun <T : CharSequence> Expect<T>.notToBe(empty: empty): Expect<T>
infix fun <T : CharSequence> Expect<T>.notToBe(blank: blank): Expect<T>
infix fun <T : Path> Expect<T>.notToBe(existing: existing): Expect<T>
inline infix fun <reified T : Any> Expect<T?>.notToBeNull(o: o): Expect<T>
inline infix fun <reified T : Any> Expect<T?>.notToBeNull(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <R, T : () -> R> Expect<T>.notToThrow(): Expect<R>
infix fun <R, T : () -> R> Expect<T>.notToThrow(assertionCreator: Expect<R>.() -> Unit): Expect<R>
object o : Keyword
fun <T> of(reason: String, assertionCreator: Expect<T>.() -> Unit): KeyWithCreator<String, T>
fun <T, A1, R> of(f: KFunction2<T, A1, R>, a1: A1): Feature<T, R>
fun <T, A1, A2, R> of(f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): Feature<T, R>
fun <T, A1, A2, A3, R> of(f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): Feature<T, R>
fun <T, A1, A2, A3, A4, R> of(f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): Feature<T, R>
fun <T, A1, A2, A3, A4, A5, R> of(f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): Feature<T, R>
fun <T, R> of(property: KProperty1<in T, R>, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, R> of(f: KFunction1<T, R>, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, R> of(f: KFunction2<T, A1, R>, a1: A1, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, A2, R> of(f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, A2, A3, R> of(f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, A2, A3, A4, R> of(f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, A1, A2, A3, A4, A5, R> of(f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
fun <T, R> of(provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>, assertionCreator: Expect<R>.() -> Unit): MetaFeatureOptionWithCreator<T, R>
fun <T, R> of(description: String, extractor: T.() -> R): Feature<T, R>
fun <T, R> of(description: String, extractor: T.() -> R, assertionCreator: Expect<R>.() -> Unit): FeatureWithCreator<T, R>
object only : Keyword
fun <E> order(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): Order<E, Group<E>>
object order : Keyword
fun <K, V> pairs(pair: Pair<K, V>, vararg otherPairs: Pair<K, V>): Pairs<K, V>
val <T : Path> Expect<T>.parent: Expect<Path>
infix fun <T : Path> Expect<T>.parent(assertionCreator: Expect<Path>.() -> Unit): Expect<T>
fun <E> path(path: String, assertionCreator: Expect<E>.() -> Unit): PathWithCreator<E>
fun <E> present(assertionCreator: Expect<E>.() -> Unit): PresentWithCreator<E>
object present : Keyword
object readable : Keyword
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.regex(pattern: String): Expect<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): Expect<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): Expect<T>
fun regexPatterns(pattern: String, vararg otherPatterns: String): RegexPatterns
object relative : Keyword
infix fun <T : Path> Expect<T>.resolve(other: String): Expect<Path>
infix fun <T : Path> Expect<T>.resolve(path: PathWithCreator<Path>): Expect<T>
val <V, T : Pair<*, V>> Expect<T>.second: Expect<V>
infix fun <K, V, T : Pair<K, V>> Expect<T>.second(assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <T : Collection<*>> Expect<T>.size: Expect<Int>
infix fun <E, T : Collection<E>> Expect<T>.size(assertionCreator: Expect<Int>.() -> Unit): Expect<T>
infix fun <T : CharSequence> Expect<T>.startsNotWith(expected: CharSequence): Expect<T>
infix fun <T : CharSequence> Expect<T>.startsNotWith(expected: Char): Expect<T>
infix fun <T : Path> Expect<T>.startsNotWith(expected: Path): Expect<T>
infix fun <T : CharSequence> Expect<T>.startsWith(expected: CharSequence): Expect<T>
infix fun <T : CharSequence> Expect<T>.startsWith(expected: Char): Expect<T>
infix fun <T : Path> Expect<T>.startsWith(expected: Path): Expect<T>
fun <E> success(assertionCreator: Expect<E>.() -> Unit): SuccessWithCreator<E>
object success : Keyword
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
@JvmName("valuesIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
@JvmName("valuesIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.the(values: Values<CharSequenceOrNumberOrChar>): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>
@JvmName("regexIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): Expect<T>
infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E : Any, T : Iterable<E?>> IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E : Any, T> IterableLikeContains.CheckerStep<out E?, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): Expect<T>
infix fun <E : Any, T> IterableLikeContains.EntryPointStep<out E?, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>.the(pairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderSearchBehaviour>.the(keyValues: KeyValues<K, V>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>.the(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InAnyOrderOnlySearchBehaviour>.the(keyValues: KeyValues<K, V>): Expect<T>
infix fun <K, V, T> MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>.the(keyValuePairs: Pairs<K, V>): Expect<T>
inline infix fun <K, reified V : Any, T> MapLikeContains.EntryPointStep<K, out V?, T, InOrderOnlySearchBehaviour>.the(keyValues: KeyValues<K, V>): Expect<T>
infix fun <T> Expect<T>.toBe(expected: T): Expect<T>
infix fun <T : CharSequence> Expect<T>.toBe(empty: empty): Expect<T>
@JvmName("toBeNull") infix fun <T : BigDecimal> Expect<T?>.toBe(expected: Nothing?): Expect<T?>
infix fun <E, T : Optional<E>> Expect<T>.toBe(present: present): FeatureExpect<T, E>
infix fun <E, T : Optional<E>> Expect<T>.toBe(present: PresentWithCreator<E>): Expect<T>
infix fun <T : Path> Expect<T>.toBe(existing: existing): Expect<T>
infix fun <T : Path> Expect<T>.toBe(readable: readable): Expect<T>
infix fun <T : Path> Expect<T>.toBe(writable: writable): Expect<T>
infix fun <T : Path> Expect<T>.toBe(executable: executable): Expect<T>
infix fun <T : Path> Expect<T>.toBe(aRegularFile: aRegularFile): Expect<T>
infix fun <T : Path> Expect<T>.toBe(aDirectory: aDirectory): Expect<T>
infix fun <T : Path> Expect<T>.toBe(absolute: absolute): Expect<T>
infix fun <T : Path> Expect<T>.toBe(relative: relative): Expect<T>
infix fun <T : Any> Expect<T?>.toBeNullIfNullGivenElse(assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Expect<T?>
inline fun <reified TExpected : Throwable> Expect<() -> Any?>.toThrow(): Expect<TExpected>
inline infix fun <reified TExpected : Throwable> Expect<() -> Any?>.toThrow(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, NoOpSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
@JvmName("valueIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
@JvmName("valueIgnoringCase") infix fun <T : CharSequence> CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
infix fun <T : CharSequence> CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>.value(expected: CharSequenceOrNumberOrChar): Expect<T>
fun <T> value(value: T): Value<T>
infix fun <E, T : Iterable<E>> IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
infix fun <E, T> IterableLikeContains.CheckerStep<E, T, InAnyOrderSearchBehaviour>.value(expected: E): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>.value(expected: E): Expect<T>
infix fun <K, V, T : Entry<K, V>> Expect<T>.value(assertionCreator: Expect<V>.() -> Unit): Expect<T>
val <V, T : Entry<*, V>> Expect<T>.value: Expect<V>
fun <T> values(value: T, vararg otherValues: T): Values<T>
infix fun <K, V, T : Map<out K, V>> Expect<T>.values(assertionCreator: Expect<Collection<V>>.() -> Unit): Expect<T>
val <V, T : Map<*, V>> Expect<T>.values: Expect<Collection<V>>
fun withEncoding(path: Path, sourceCharset: Charset = Charsets.UTF_8, targetCharset: Charset = Charsets.UTF_8): PathWithEncoding
infix fun <E, T : Iterable<E>> IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within(group: group): IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
infix fun <E, T> IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>.within(group: group): IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
infix fun <T> RootExpect<T>.withOptions(configuration: ExpectBuilder.OptionsChooser<T>.() -> Unit): Expect<T>
infix fun <T> RootExpect<T>.withOptions(options: ExpectOptions<T>): Expect<T>
infix fun <T, R> FeatureExpect<T, R>.withOptions(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): Expect<R>
infix fun <T, R> FeatureExpect<T, R>.withOptions(options: FeatureExpectOptions<R>): Expect<R>
infix fun <T> RootExpect<T>.withRepresentation(textRepresentation: String): Expect<T>
infix fun <T> RootExpect<T>.withRepresentation(representationProvider: (T) -> Any): Expect<T>
infix fun <T, R> FeatureExpect<T, R>.withRepresentation(textRepresentation: String): Expect<R>
infix fun <T, R> FeatureExpect<T, R>.withRepresentation(representationProvider: (R) -> Any): Expect<R>
object writable : Keyword
val Expect<LocalDate>.year: Expect<Int>
val Expect<LocalDateTime>.year: Expect<Int>
val Expect<ZonedDateTime>.year: Expect<Int>
infix fun Expect<LocalDate>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDate>
infix fun Expect<LocalDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<LocalDateTime>
infix fun Expect<ZonedDateTime>.year(assertionCreator: Expect<Int>.() -> Unit): Expect<ZonedDateTime>

package ch.tutteli.atrium.api.infix.en_GB.creating

class All<out T> : VarArgHelper<T>

val expected: T
val otherExpected: Array<out T>

class Entries<T> : GroupWithoutNullableEntries<(Expect<T>.() -> Unit)?>, GroupWithNullableEntries<(Expect<T>.() -> Unit)?>, VarArgHelper<(Expect<T>.() -> Unit)?>

val assertionCreatorOrNull: (Expect<T>.() -> Unit)?
val expected: (Expect<T>.() -> Unit)?
val otherAssertionCreatorsOrNulls: Array<(Expect<T>.() -> Unit)?>
val otherExpected: Array<(Expect<T>.() -> Unit)?>
fun toList(): List<(Expect<T>.() -> Unit)?>

data class Entry<T : Any> : GroupWithoutNullableEntries<(Expect<T>.() -> Unit)?>, GroupWithNullableEntries<(Expect<T>.() -> Unit)?>

val assertionCreatorOrNull: (Expect<T>.() -> Unit)?
fun toList(): List<(Expect<T>.() -> Unit)?>

data class IndexWithCreator<E>

val assertionCreator: Expect<E>.() -> Unit
val index: Int

data class KeyWithCreator<out K, V>

val assertionCreator: Expect<V>.() -> Unit
val key: K

class Pairs<out K, out V> : VarArgHelper<Pair<K, V>>

val expected: Pair<K, V>
val otherExpected: Array<out Pair<K, V>>

data class PresentWithCreator<E>

val assertionCreator: Expect<E>.() -> Unit

class RegexPatterns : VarArgHelper<String>

val expected: String
val otherExpected: Array<out String>

data class SuccessWithCreator<E>

val assertionCreator: Expect<E>.() -> Unit

data class Value<T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>

val expected: T
fun toList(): List<T>

class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>

val expected: T
val otherExpected: Array<out T>
fun toList(): List<T>

package ch.tutteli.atrium.api.infix.en_GB.creating.charsequence.contains.builders

interface AtLeastCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>

package ch.tutteli.atrium.api.infix.en_GB.creating.feature

data class Feature<T, R>

val description: String
val extractor: (T) -> R

data class FeatureWithCreator<T, R>

val assertionCreator: Expect<R>.() -> Unit
val description: String
val extractor: (T) -> R

data class MetaFeatureOptionWithCreator<T, R>

val assertionCreator: Expect<R>.() -> Unit
val provider: MetaFeatureOption<T>.(T) -> MetaFeature<R>

package ch.tutteli.atrium.api.infix.en_GB.creating.iterable

class Order<out T, out G : Group<T>>

val firstGroup: G
val otherExpectedGroups: Array<out G>
val secondGroup: G
fun toList(): List<List<T>>

package ch.tutteli.atrium.api.infix.en_GB.creating.iterable.contains.builders

interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

package ch.tutteli.atrium.api.infix.en_GB.creating.map

class KeyValues<out K, V : Any> : VarArgHelper<KeyWithValueCreator<K, V>>

val expected: KeyWithValueCreator<K, V>
val otherExpected: Array<out KeyWithValueCreator<K, V>>

data class KeyWithValueCreator<out K, V : Any>

val key: K
fun toPair(): Pair<K, (Expect<V>.() -> Unit)?>
fun toString(): String
val valueAssertionCreatorOrNull: (Expect<V>.() -> Unit)?

package ch.tutteli.atrium.api.infix.en_GB.creating.path

class DirectoryEntries : VarArgHelper<String>

DirectoryEntries(expected: String, otherExpected: Array<out String>)
val expected: String
val otherExpected: Array<out String>

data class PathWithCreator<E>

val assertionCreator: Expect<E>.() -> Unit
val path: String

data class PathWithEncoding

val path: Path
val sourceCharset: Charset
val targetCharset: Charset

package ch.tutteli.atrium.api.infix.en_GB.kotlin_1_3

inline fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(): Expect<TExpected>
inline infix fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(noinline assertionCreator: Expect<TExpected>.() -> Unit): Expect<TExpected>
infix fun <E, T : Result<E>> Expect<T>.toBe(success: success): Expect<E>
infix fun <E, T : Result<E>> Expect<T>.toBe(success: SuccessWithCreator<E>): Expect<T>

package ch.tutteli.atrium.api.infix.en_GB.workaround

inline infix fun <T> Expect<T>.it(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>

package ch.tutteli.atrium.api.verbs

fun <T> assert(subject: T): RootExpect<T>
fun <T> assert(subject: T, assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.assert(newSubject: R): FeatureExpect<T, R>
enum class AssertionVerb : StringBasedTranslatable

ASSERT
ASSERT_THAT
EXPECT
val value: String

fun <T> assertThat(subject: T): RootExpect<T>
fun <T> assertThat(subject: T, assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.assertThat(newSubject: R): FeatureExpect<T, R>
fun <T> expect(subject: T): RootExpect<T>
fun <T> expect(subject: T, assertionCreator: Expect<T>.() -> Unit): Expect<T>
fun <T, R> Expect<T>.expect(newSubject: R): FeatureExpect<T, R>

package ch.tutteli.atrium.assertions

fun <T : CharSequence> _containsBuilder(plant: AssertionPlant<T>): CharSequenceContains.Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> _containsNotBuilder(plant: AssertionPlant<T>): CharSequenceContains.Builder<T, NotSearchBehaviour>
fun <T : Any, TSub : T> _downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> _endsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : CharSequence> _endsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : Collection<*>> _hasSize(plant: AssertionPlant<T>, size: Int): Assertion
inline fun <reified TSub : Any> _isA(plant: AssertionPlant<Any>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> _isEmpty(plant: AssertionPlant<T>): Assertion
fun <T : BigDecimal> _isEqualIncludingScale(plant: AssertionPlant<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
fun <T : Comparable<T>> _isGreaterOrEquals(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Comparable<T>> _isGreaterThan(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Comparable<T>> _isLessOrEquals(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Comparable<T>> _isLessThan(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : CharSequence> _isNotEmpty(plant: AssertionPlant<T>): Assertion
fun <T : BigDecimal> _isNotEqualIncludingScale(plant: AssertionPlant<T>, expected: T): Assertion
inline fun <reified T : Any> _isNotNull(plant: AssertionPlantNullable<T?>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Unit
fun <T : BigDecimal> _isNotNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any> _isNotSame(plant: AssertionPlant<T>, expected: T): Assertion
fun <T> _isNull(plant: AssertionPlantNullable<T>): Assertion
fun <T : BigDecimal> _isNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any> _isSame(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any> _notToBe(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : CharSequence> _startsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : CharSequence> _startsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : Any> _toBe(plant: AssertionPlant<T>, expected: T): Assertion
fun _toBeWithErrorTolerance(plant: AssertionPlant<Float>, expected: Float, tolerance: Float): Assertion
fun _toBeWithErrorTolerance(plant: AssertionPlant<Double>, expected: Double, tolerance: Double): Assertion
fun <T : BigDecimal> _toBeWithErrorTolerance(plant: AssertionPlant<T>, expected: T, tolerance: T): Assertion
fun <TExpected : Throwable> _toThrow(throwableThrownBuilder: ThrowableThrownBuilder, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit
fun <T : Any, TSub : Any> _typeTransformation(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, warningTransformationFailed: Translatable, canBeTransformed: (T) -> Boolean, transform: (T) -> TSub): Unit
interface Assertion

abstract fun holds(): Boolean

interface AssertionGroup : Assertion

abstract val assertions: List<Assertion>
object Builder

class BasicAssertionGroupBuilder

BasicAssertionGroupBuilder(groupType: AssertionGroupType)
fun create(name: Translatable, subject: Any, assertion: Assertion): AssertionGroup
fun create(name: Translatable, subject: Any, assertions: List<Assertion>): AssertionGroup

class EmptyNameAndSubjectAssertionGroupBuilder

EmptyNameAndSubjectAssertionGroupBuilder(groupType: AssertionGroupType)
fun create(assertion: Assertion): AssertionGroup
fun create(assertions: List<Assertion>): AssertionGroup

val explanatory: AssertionGroup.Builder.ExplanatoryAssertionGroupOption
class ExplanatoryAssertionGroupBuilder

ExplanatoryAssertionGroupBuilder(groupType: ExplanatoryAssertionGroupType)
fun create(assertion: Assertion): ExplanatoryAssertionGroup
fun create(assertions: List<Assertion>): ExplanatoryAssertionGroup

class ExplanatoryAssertionGroupOption

ExplanatoryAssertionGroupOption()
val withDefault: AssertionGroup.Builder.ExplanatoryAssertionGroupBuilder
fun withType(groupType: ExplanatoryAssertionGroupType): AssertionGroup.Builder.ExplanatoryAssertionGroupBuilder
val withWarning: AssertionGroup.Builder.ExplanatoryAssertionGroupBuilder

val feature: AssertionGroup.Builder.BasicAssertionGroupBuilder
val invisible: AssertionGroup.Builder.EmptyNameAndSubjectAssertionGroupBuilder
val list: AssertionGroup.Builder.BasicAssertionGroupBuilder
val root: AssertionGroup.Builder.BasicAssertionGroupBuilder
val summary: AssertionGroup.Builder.BasicAssertionGroupBuilder
fun withType(groupType: AssertionGroupType): AssertionGroup.Builder.BasicAssertionGroupBuilder

abstract val description: Translatable
open fun holds(): Boolean
open val name: Translatable
abstract val representation: Any
open val subject: Any
abstract val type: AssertionGroupType

interface AssertionGroupType : BulletPointIdentifier
data class BasicAssertionGroup : AssertionGroup

BasicAssertionGroup(type: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>)
val assertions: List<Assertion>
val description: Translatable
val representation: Any
val type: AssertionGroupType

class BasicDescriptiveAssertion : DescriptiveAssertion

BasicDescriptiveAssertion(description: Translatable, representation: Any, holds: Boolean)
BasicDescriptiveAssertion(description: Translatable, representation: Any, test: () -> Boolean)
val description: Translatable
fun holds(): Boolean
val representation: Any

class BasicExplanatoryAssertion : ExplanatoryAssertion

BasicExplanatoryAssertion(explanation: Any?)
val explanation: Any?
fun toString(): String

interface BulletPointIdentifier
object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType
object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType
object DefaultIndentAssertionGroupType : IndentAssertionGroupType
object DefaultListAssertionGroupType : ListAssertionGroupType
object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType
enum class DescriptionAnyAssertion : StringBasedTranslatable

IS_NOT_SAME
IS_SAME
NOT_TO_BE
TO_BE
val value: String

enum class DescriptionBasic : StringBasedTranslatable

IS
IS_NOT
val value: String

enum class DescriptionBigDecimalAssertion : StringBasedTranslatable

FAILURE_TO_BE_BUT_NUMERICALLY_EQUAL
IS_EQUAL_INCLUDING_SCALE
IS_NOT_EQUAL_INCLUDING_SCALE
IS_NOT_NUMERICALLY_EQUAL_TO
IS_NUMERICALLY_EQUAL_TO
val value: String

enum class DescriptionCharSequenceAssertion : StringBasedTranslatable

AT_LEAST
AT_MOST
CONTAINS
CONTAINS_NOT
EMPTY
ENDS_NOT_WITH
ENDS_WITH
EXACTLY
IGNORING_CASE
NUMBER_OF_OCCURRENCES
STARTS_NOT_WITH
STARTS_WITH
val value: String

enum class DescriptionCollectionAssertion : StringBasedTranslatable

EMPTY
HAS_SIZE
val value: String

enum class DescriptionComparableAssertion : StringBasedTranslatable

IS_GREATER_OR_EQUALS
IS_GREATER_THAN
IS_LESS_OR_EQUALS
IS_LESS_THAN
val value: String

enum class DescriptionFloatingPointAssertion : StringBasedTranslatable

FAILURE_DUE_TO_FLOATING_POINT_NUMBER
TO_BE_WITH_ERROR_TOLERANCE
TO_BE_WITH_ERROR_TOLERANCE_EXPLAINED
val value: String

enum class DescriptionIterableAssertion : StringBasedTranslatable

AN_ENTRY_WHICH
AN_ENTRY_WHICH_IS
AT_LEAST
AT_MOST
CANNOT_EVALUATE_SUBJECT_EMPTY_ITERABLE
CANNOT_EVALUATE_SUBJECT_ONLY_NULL
CONTAINS
CONTAINS_NOT
ENTRY_WITH_INDEX
EXACTLY
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
NUMBER_OF_OCCURRENCES
SIZE_EXCEEDED
val value: String
WARNING_ADDITIONAL_ENTRIES
WARNING_MISMATCHES
WARNING_MISMATCHES_ADDITIONAL_ENTRIES

enum class DescriptionThrowableAssertion : StringBasedTranslatable

IS_A
NO_EXCEPTION_OCCURRED
val value: String

enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable

IS_A
val value: String
WARNING_DOWN_CAST_FAILED

interface DescriptiveAssertion : Assertion

abstract val description: Translatable
open val expected: Any
abstract val representation: Any

interface DoNotFilterAssertionGroupType : AssertionGroupType
open class EmptyNameAndRepresentationAssertionGroup : AssertionGroup

EmptyNameAndRepresentationAssertionGroup(type: AssertionGroupType, assertions: List<Assertion>)
open val assertions: List<Assertion>
open val description: Translatable
open val representation: Any
open val type: AssertionGroupType

interface ExplanatoryAssertion : Assertion

abstract val explanation: Any?
open fun holds(): Boolean

class ExplanatoryAssertionGroup : EmptyNameAndRepresentationAssertionGroup

fun holds(): Boolean

interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType
interface FeatureAssertionGroupType : AssertionGroupType
class IndentAssertionGroup : EmptyNameAndRepresentationAssertionGroup

IndentAssertionGroup(assertions: List<Assertion>)

interface IndentAssertionGroupType : AssertionGroupType
data class InformationAssertionGroupType : ExplanatoryAssertionGroupType

InformationAssertionGroupType(withIndent: Boolean)
val withIndent: Boolean

class InvisibleAssertionGroup : EmptyNameAndRepresentationAssertionGroup
object InvisibleAssertionGroupType : AssertionGroupType
interface ListAssertionGroupType : AssertionGroupType
class PrefixFailingSummaryAssertion : BulletPointIdentifier
class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier
class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier
interface RepresentationOnlyAssertion : Assertion

abstract val representation: Any?

object RootAssertionGroupType : AssertionGroupType
interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType
object WarningAssertionGroupType : ExplanatoryAssertionGroupType

package ch.tutteli.atrium.assertions.any.typetransformation

interface AnyTypeTransformation

interface TypeTransformationFailureHandler<in T : Any, out TSub : Any>

abstract fun createAndAddAssertionToPlant(warningTransformationFailed: Translatable, subjectPlant: BaseAssertionPlant<T?, *>, failingAssertion: Assertion, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

class DownCaster<T : Any, TSub : T>

DownCaster(failureHandler: AnyTypeTransformation.TypeTransformationFailureHandler<T, TSub>)
fun downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

class ExplanatoryTypeTransformationFailureHandler<T : Any, out TSub : T> : AnyTypeTransformation.TypeTransformationFailureHandler<T, TSub>

ExplanatoryTypeTransformationFailureHandler()
fun createAndAddAssertionToPlant(warningTransformationFailed: Translatable, subjectPlant: BaseAssertionPlant<T?, *>, failingAssertion: Assertion, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit

class TypeTransformer<T : Any, TSub : Any>

TypeTransformer(failureHandler: AnyTypeTransformation.TypeTransformationFailureHandler<T, TSub>)
fun transform(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, warningTransformationFailed: Translatable, canBeTransformed: (T) -> Boolean, transform: (T) -> TSub): Unit

package ch.tutteli.atrium.assertions.basic.contains

interface Contains

interface Checker : Contains.Checker
interface Creator<in T : Any, in SC> : Contains.Creator<T, SC>
interface SearchBehaviour : Contains.SearchBehaviour

package ch.tutteli.atrium.assertions.basic.contains.builders

abstract class ContainsBuilder<out T : Any, out S : Contains.SearchBehaviour> : Contains.Builder<T, S>

ContainsBuilder(subjectProvider: AssertionPlant<T>, searchBehaviour: S)
open val searchBehaviour: S
open val subjectProvider: AssertionPlant<T>

interface ContainsCheckerBuilder<out T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.Builder<T, S>> : Contains.CheckerOption<T, S, C, B>
fun validateAtMost(times: Int, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
fun validateButAtMost(atLeastTimes: Int, butAtMostTimes: Int, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String): Unit

package ch.tutteli.atrium.assertions.basic.contains.checkers

abstract class ContainsChecker : Contains.Checker

ContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)
protected fun createBasicAssertion(description: Translatable, check: Boolean): DescriptiveAssertion
val times: Int

package ch.tutteli.atrium.assertions.basic.contains.creators

abstract class ContainsAssertionCreator<T : Any, S, C : Contains.Checker> : Contains.Creator<T, S>

ContainsAssertionCreator(checkers: List<C>)
fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriteria: List<S>): AssertionGroup
fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriterion: S, otherSearchCriteria: Array<out S>): AssertionGroup
protected abstract fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected abstract fun searchAndCreateAssertion(subjectProvider: SubjectProvider<T>, searchCriterion: S, featureFactory: (numberOfOccurrences: Int, description: Translatable) -> AssertionGroup): AssertionGroup

abstract class ContainsObjectsAssertionCreator<T : Any, S, B : Contains.SearchBehaviour, C : Contains.Checker> : ContainsAssertionCreator<T, S, C>

ContainsObjectsAssertionCreator(searchBehaviour: B, checkers: List<C>)
protected fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected abstract val descriptionContains: Translatable
protected abstract val descriptionNumberOfOccurrences: Translatable
protected abstract fun search(subjectProvider: SubjectProvider<T>, searchCriterion: S): Int
protected fun searchAndCreateAssertion(subjectProvider: SubjectProvider<T>, searchCriterion: S, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

package ch.tutteli.atrium.assertions.builders

val assertionBuilder: AssertionBuilder
interface AssertionBuilder

open fun createDescriptive(description: String, representation: Any?, test: () -> Boolean): DescriptiveAssertion
open fun createDescriptive(description: Translatable, representation: Any?, test: () -> Boolean): DescriptiveAssertion
open fun <T> createDescriptive(subjectProvider: SubjectProvider<T>, description: String, representation: Any?, test: (T) -> Boolean): DescriptiveAssertion
open fun <T> createDescriptive(subjectProvider: SubjectProvider<T>, description: Translatable, representation: Any?, test: (T) -> Boolean): DescriptiveAssertion
abstract fun <T : AssertionGroupType> customType(groupType: T): DefaultAssertionGroupBuilderOptions<T>
abstract val descriptive: Descriptive.HoldsOption
abstract val explanatory: Explanatory.ExplanationOption
abstract val explanatoryGroup: ExplanatoryAssertionGroupTypeOption
abstract val feature: DefaultAssertionGroupBuilderOptions<FeatureAssertionGroupType>
abstract val list: DefaultAssertionGroupBuilderOptions<ListAssertionGroupType>
abstract val representationOnly: RepresentationOnly.HoldsStep
abstract val summary: AssertionGroupDescriptionAndEmptyRepresentationOption<SummaryAssertionGroupType, AssertionsOption<SummaryAssertionGroupType, BasicAssertionGroupFinalStep>>

interface AssertionBuilderFinalStep<T : Assertion>

abstract fun build(): T

interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType, R> create(type: T, factory: (T, Translatable, Any) -> R): AssertionGroupDescriptionAndEmptyRepresentationOption<T, R>
abstract val groupType: T
open fun withDescription(description: String): R
abstract fun withDescription(description: Translatable): R

interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>

fun <T : AssertionGroupType, R> create(type: T, factory: (T, Translatable, Any) -> R): AssertionGroupDescriptionAndRepresentationOption<T, R>
abstract val groupType: T
open fun withDescriptionAndEmptyRepresentation(description: String): R
open fun withDescriptionAndEmptyRepresentation(description: Translatable): R
open fun withDescriptionAndRepresentation(description: String, representationProvider: () -> Any?): R
open fun withDescriptionAndRepresentation(description: Translatable, representationProvider: () -> Any?): R
open fun withDescriptionAndRepresentation(description: String, representation: Any?): R
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): R

interface AssertionsOption<out T : AssertionGroupType, out R>

fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
fun <T : AssertionGroupType> factoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>

interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>

abstract val assertions: List<Assertion>
fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>): BasicAssertionGroupFinalStep
abstract val description: Translatable
abstract val groupType: AssertionGroupType
abstract val representation: Any

typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
interface Descriptive

interface DescriptionOption<R>

fun <R> create(test: () -> Boolean, factory: (() -> Boolean, Translatable, Any) -> R): Descriptive.DescriptionOption<R>
abstract val test: () -> Boolean
open fun withDescriptionAndRepresentation(description: String, representation: Any?): R
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): R

interface FinalStep : AssertionBuilderFinalStep<DescriptiveAssertion>

fun create(test: () -> Boolean, description: Translatable, representation: Any): Descriptive.FinalStep
abstract val description: Translatable
abstract val representation: Any
abstract val test: () -> Boolean

interface HoldsOption

fun create(): Descriptive.HoldsOption
abstract val failing: Descriptive.DescriptionOption<Descriptive.FinalStep>
abstract val holding: Descriptive.DescriptionOption<Descriptive.FinalStep>
abstract fun withTest(test: () -> Boolean): Descriptive.DescriptionOption<Descriptive.FinalStep>
abstract fun <T> withTest(subjectProvider: SubjectProvider<T>, test: (T) -> Boolean): Descriptive.DescriptionOption<Descriptive.FinalStep>

interface DescriptiveAssertionWithFailureHint

interface FailureHintSubjectAbsentOption<T> : SubjectBasedOption.AbsentOption<T, Assertion>

fun <T> create(ifDefined: (T) -> Assertion): DescriptiveAssertionWithFailureHint.FailureHintSubjectAbsentOption<T>

interface FailureHintSubjectDefinedOption<T> : SubjectBasedOption.DefinedOption<T, Assertion, DescriptiveAssertionWithFailureHint.FailureHintSubjectAbsentOption<T>>

fun <T> create(): DescriptiveAssertionWithFailureHint.FailureHintSubjectDefinedOption<T>

interface FinalStep : AssertionBuilderFinalStep<Assertion>

fun create(test: () -> Boolean, showHint: () -> Boolean, failureHintFactory: () -> Assertion, description: Translatable, representation: Any): DescriptiveAssertionWithFailureHint.FinalStep
abstract val description: Translatable
abstract val failureHintFactory: () -> Assertion
abstract val representation: Any
abstract val showHint: () -> Boolean
abstract val test: () -> Boolean

interface ShowOption

fun create(test: () -> Boolean, failureHintFactory: () -> Assertion): DescriptiveAssertionWithFailureHint.ShowOption
open fun <T> showBasedOnDefinedSubjectOnlyIf(subjectProvider: SubjectProvider<T>, predicate: (T) -> Boolean): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
open fun <T> showBasedOnSubjectOnlyIf(subjectProvider: SubjectProvider<T>, showSubStep: DescriptiveAssertionWithFailureHint.ShowSubjectDefinedOption<T>.() -> Pair<() -> Boolean, (T) -> Boolean>): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
abstract val showForAnyFailure: Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
abstract fun showOnlyIf(predicate: () -> Boolean): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
open fun <T> showOnlyIfSubjectDefined(subjectProvider: SubjectProvider<T>): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>

interface ShowSubjectAbsentOption<T> : SubjectBasedOption.AbsentOption<T, Boolean>

fun <T> create(ifDefined: (T) -> Boolean): DescriptiveAssertionWithFailureHint.ShowSubjectAbsentOption<T>

interface ShowSubjectDefinedOption<T> : SubjectBasedOption.DefinedOption<T, Boolean, DescriptiveAssertionWithFailureHint.ShowSubjectAbsentOption<T>>

fun <T> create(): DescriptiveAssertionWithFailureHint.ShowSubjectDefinedOption<T>

interface Explanatory

interface ExplanationOption

fun create(): Explanatory.ExplanationOption
open fun withDescription(translatable: Translatable, arg: Any, vararg otherArgs: Any): Explanatory.FinalStep
open fun withDescription(translatable: Translatable): Explanatory.FinalStep
open fun withDescription(explanation: Any?): Explanatory.FinalStep
open fun withExplanation(translatable: Translatable, arg: Any, vararg otherArgs: Any): Explanatory.FinalStep
open fun withExplanation(description: String): Explanatory.FinalStep
abstract fun withExplanation(explanation: Any?): Explanatory.FinalStep

interface FinalStep : AssertionBuilderFinalStep<ExplanatoryAssertion>

fun create(explanation: Any?): Explanatory.FinalStep
abstract val explanation: Any?

interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>

fun create(groupType: ExplanatoryAssertionGroupType, explanatoryAssertions: List<Assertion>): ExplanatoryAssertionGroupFinalStep
abstract val explanatoryAssertions: List<Assertion>
abstract val failing: ExplanatoryAssertionGroupFinalStep
abstract val groupType: ExplanatoryAssertionGroupType

interface ExplanatoryAssertionGroupTypeOption

abstract val withDefaultType: AssertionsOption<DefaultExplanatoryAssertionGroupType, ExplanatoryAssertionGroupFinalStep>
abstract fun withInformationType(withIndent: Boolean): AssertionsOption<InformationAssertionGroupType, ExplanatoryAssertionGroupFinalStep>
abstract fun <T : ExplanatoryAssertionGroupType> withType(groupType: T): AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>
abstract val withWarningType: AssertionsOption<WarningAssertionGroupType, ExplanatoryAssertionGroupFinalStep>

interface ExplanatoryGroup

interface FinalStep : AssertionBuilderFinalStep<AssertionGroup>, ExplanatoryAssertionGroupFinalStep

fun create(groupType: ExplanatoryAssertionGroupType, explanatoryAssertions: List<Assertion>, holds: Boolean = true): ExplanatoryGroup.FinalStep
abstract val explanatoryAssertions: List<Assertion>
open val failing: ExplanatoryGroup.FinalStep
abstract val groupType: ExplanatoryAssertionGroupType

interface GroupTypeOption : ExplanatoryAssertionGroupTypeOption

fun create(): ExplanatoryGroup.GroupTypeOption
abstract val withDefaultType: AssertionsOption<DefaultExplanatoryAssertionGroupType, ExplanatoryGroup.FinalStep>
abstract fun withInformationType(withIndent: Boolean): AssertionsOption<InformationAssertionGroupType, ExplanatoryGroup.FinalStep>
abstract fun <T : ExplanatoryAssertionGroupType> withType(groupType: T): AssertionsOption<T, ExplanatoryGroup.FinalStep>
abstract val withWarningType: AssertionsOption<WarningAssertionGroupType, ExplanatoryGroup.FinalStep>

val AssertionBuilder.fixedClaimGroup: FixedClaimGroup.GroupTypeOption
interface FixedClaimGroup

interface FinalStep : BasicAssertionGroupFinalStep

fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>, holds: Boolean): FixedClaimGroup.FinalStep
abstract val holds: Boolean

interface GroupTypeOption : FixedClaimLikeGroup.GroupTypeOption<FixedClaimGroup.FinalStep>

fun create(): FixedClaimGroup.GroupTypeOption

interface HoldsOption<T : AssertionGroupType> : FixedClaimLikeGroup.HoldsOption<T, FixedClaimGroup.FinalStep>

fun <T : AssertionGroupType> create(groupType: T): FixedClaimGroup.HoldsOption<T>

interface FixedClaimLikeGroup

interface GroupTypeOption<R>

open val withFeatureType: FixedClaimLikeGroup.HoldsOption<FeatureAssertionGroupType, R>
open val withListType: FixedClaimLikeGroup.HoldsOption<ListAssertionGroupType, R>
abstract fun <T : AssertionGroupType> withType(groupType: T): FixedClaimLikeGroup.HoldsOption<T, R>

interface HoldsOption<T : AssertionGroupType, R>

abstract val failing: AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, R>>
abstract val groupType: T
abstract val holding: AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, R>>
abstract fun withClaim(holds: Boolean): AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, R>>

val AssertionBuilder.invisibleGroup: AssertionsOption<InvisibleAssertionGroupType, BasicAssertionGroupFinalStep>
val AssertionBuilder.partiallyFixedClaimGroup: PartiallyFixedClaimGroup.GroupTypeOption
interface PartiallyFixedClaimGroup

interface FinalStep : BasicAssertionGroupFinalStep

fun create(groupType: AssertionGroupType, description: Translatable, representation: Any, assertions: List<Assertion>, holds: Boolean): PartiallyFixedClaimGroup.FinalStep
abstract val preTransformationHolds: Boolean

interface GroupTypeOption : FixedClaimLikeGroup.GroupTypeOption<PartiallyFixedClaimGroup.FinalStep>

fun create(): PartiallyFixedClaimGroup.GroupTypeOption

interface HoldsOption<T : AssertionGroupType> : FixedClaimLikeGroup.HoldsOption<T, PartiallyFixedClaimGroup.FinalStep>

fun <T : AssertionGroupType> create(groupType: T): PartiallyFixedClaimGroup.HoldsOption<T>

interface RepresentationOnly

interface FinalStep : AssertionBuilderFinalStep<RepresentationOnlyAssertion>

fun create(test: () -> Boolean, representation: Any?): RepresentationOnly.FinalStep
abstract val representation: Any?
abstract val test: () -> Boolean

interface HoldsStep : HoldsStep<RepresentationOnly.RepresentationStep>

fun create(): RepresentationOnly.HoldsStep

interface RepresentationStep

fun create(test: () -> Boolean): RepresentationOnly.RepresentationStep
abstract val test: () -> Boolean
abstract fun withRepresentation(representation: Any?): RepresentationOnly.FinalStep

val AssertionBuilder.root: DefaultAssertionGroupBuilderOptions<RootAssertionGroupType>
interface SubjectBasedOption

interface AbsentOption<T, R>

open infix fun ifAbsent(failureHintFactory: () -> R): Pair<() -> R, (T) -> R>
abstract val ifDefined: (T) -> R

interface DefinedOption<T, R, AO : SubjectBasedOption.AbsentOption<T, R>>

abstract fun ifDefined(failureHintFactory: (T) -> R): AO

operator fun <T, R, PO : SubjectBasedOption.DefinedOption<T, R, *>> invoke(subjectProvider: SubjectProvider<T>, subStep: PO.() -> Pair<() -> R, (T) -> R>, presentOptionFactory: () -> PO): R

fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(translatable: Translatable): ExplanatoryAssertionGroupFinalStep
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(representation: Any?): ExplanatoryAssertionGroupFinalStep
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(translatable: Translatable, arg: Any, vararg otherArgs: Any): ExplanatoryAssertionGroupFinalStep
inline fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(explanationStep: (Explanatory.ExplanationOption) -> Assertion): ExplanatoryAssertionGroupFinalStep
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertions(translatable: Translatable, arg: Any, vararg otherArgs: Any): ExplanatoryAssertionGroupFinalStep
fun Descriptive.DescriptionOption<Descriptive.FinalStep>.withFailureHint(failureHintFactory: () -> Assertion): DescriptiveAssertionWithFailureHint.ShowOption
fun <T> Descriptive.DescriptionOption<Descriptive.FinalStep>.withFailureHintBasedOnDefinedSubject(subjectProvider: SubjectProvider<T>, failureHintFactory: (T) -> Assertion): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
fun <T> Descriptive.DescriptionOption<Descriptive.FinalStep>.withFailureHintBasedOnSubject(subjectProvider: SubjectProvider<T>, failureHintSubStep: DescriptiveAssertionWithFailureHint.FailureHintSubjectDefinedOption<T>.() -> Pair<() -> Assertion, (T) -> Assertion>): DescriptiveAssertionWithFailureHint.ShowOption

package ch.tutteli.atrium.assertions.builders.common

interface HoldsStep<R>

abstract val failing: R
abstract val holding: R
abstract fun withTest(test: () -> Boolean): R
abstract fun <T> withTest(subjectProvider: SubjectProvider<T>, test: (T) -> Boolean): R

package ch.tutteli.atrium.assertions.charsequence.contains

interface CharSequenceContains

interface Checker : Contains.Checker, CharSequenceContains.Checker
interface Creator<in T : CharSequence, in SC> : Contains.Creator<T, SC>, CharSequenceContains.Creator<T, SC>
interface SearchBehaviour : Contains.SearchBehaviour, CharSequenceContains.SearchBehaviour
interface Searcher<S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.Searcher<S, Any>

package ch.tutteli.atrium.assertions.charsequence.contains.builders

abstract class CharSequenceContainsAtLeastCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtLeastCheckerBuilderBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class CharSequenceContainsAtMostCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsAtMostCheckerBuilderBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

class CharSequenceContainsBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ContainsBuilder<T, S>, CharSequenceContains.Builder<T, S>

CharSequenceContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)

abstract class CharSequenceContainsButAtMostCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilderBase<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

interface CharSequenceContainsCheckerBuilder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : ContainsCheckerBuilder<T, S, CharSequenceContains.Checker, CharSequenceContains.Builder<T, S>>, CharSequenceContains.CheckerOption<T, S>
abstract class CharSequenceContainsExactlyCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsExactlyCheckerBuilderBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class CharSequenceContainsNotCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotCheckerBuilderBase(containsBuilder: CharSequenceContains.Builder<T, S>)
open val checkers: List<CharSequenceContainsNotChecker>
open val containsBuilder: CharSequenceContains.Builder<T, S>

abstract class CharSequenceContainsNotOrAtMostCheckerBuilderBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>

CharSequenceContainsNotOrAtMostCheckerBuilderBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

package ch.tutteli.atrium.assertions.charsequence.contains.checkers

class CharSequenceContainsAtLeastChecker : CharSequenceContainsChecker

CharSequenceContainsAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

class CharSequenceContainsAtMostChecker : CharSequenceContainsChecker

CharSequenceContainsAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

abstract class CharSequenceContainsChecker : ContainsChecker, CharSequenceContains.Checker

CharSequenceContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)

class CharSequenceContainsExactlyChecker : CharSequenceContainsChecker

CharSequenceContainsExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

class CharSequenceContainsNotChecker : CharSequenceContains.Checker

CharSequenceContainsNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

package ch.tutteli.atrium.assertions.charsequence.contains.creators

fun <T : CharSequence> _containsDefaultTranslationOf(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: Translatable, otherExpected: Array<out Translatable>): AssertionGroup
fun <T : CharSequence> _containsDefaultTranslationOfIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: Translatable, otherExpected: Array<out Translatable>): AssertionGroup
fun <T : CharSequence> _containsRegex(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: String, otherExpected: Array<out String>): AssertionGroup
fun <T : CharSequence> _containsRegexIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: String, otherExpected: Array<out String>): AssertionGroup
fun <T : CharSequence> _containsValues(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: Any, otherExpected: Array<out Any>): AssertionGroup
fun <T : CharSequence> _containsValuesIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: Any, otherExpected: Array<out Any>): AssertionGroup
class CharSequenceContainsAssertionCreator<T : CharSequence, S : CharSequenceContains.SearchBehaviour> : ContainsObjectsAssertionCreator<T, Any, S, CharSequenceContains.Checker>, CharSequenceContains.Creator<T, Any>

CharSequenceContainsAssertionCreator(searchBehaviour: S, searcher: CharSequenceContains.Searcher<S, Any>, checkers: List<CharSequenceContains.Checker>)
protected val descriptionContains: DescriptionCharSequenceAssertion
protected val descriptionNumberOfOccurrences: DescriptionCharSequenceAssertion
protected fun search(subjectProvider: SubjectProvider<T>, searchCriterion: Any): Int

package ch.tutteli.atrium.assertions.charsequence.contains.searchbehaviours

fun <T : CharSequence> _containsIgnoringCase(containsBuilder: CharSequenceContainsBuilder<T, CharSequenceContainsNoOpSearchBehaviour>): CharSequenceContainsBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>
open class CharSequenceContainsIgnoringCaseSearchBehaviour : CharSequenceContains.SearchBehaviour, IgnoringCaseSearchBehaviour

CharSequenceContainsIgnoringCaseSearchBehaviour(previousBehaviour: NoOpSearchBehaviour)
open fun decorateDescription(description: Translatable): Translatable

open class CharSequenceContainsNoOpSearchBehaviour : CharSequenceContains.SearchBehaviour, NoOpSearchBehaviour

CharSequenceContainsNoOpSearchBehaviour()

open class CharSequenceContainsNotSearchBehaviour : CharSequenceContainsNoOpSearchBehaviour, NotSearchBehaviour

CharSequenceContainsNotSearchBehaviour()
open fun decorateDescription(description: Translatable): DescriptionCharSequenceAssertion

package ch.tutteli.atrium.assertions.charsequence.contains.searchers

class CharSequenceContainsIgnoringCaseIndexSearcher : CharSequenceContains.Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>

CharSequenceContainsIgnoringCaseIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class CharSequenceContainsIgnoringCaseRegexSearcher : CharSequenceContains.Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>

CharSequenceContainsIgnoringCaseRegexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class CharSequenceContainsIndexSearcher : CharSequenceContains.Searcher<CharSequenceContainsNoOpSearchBehaviour>

CharSequenceContainsIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class CharSequenceContainsRegexSearcher : CharSequenceContains.Searcher<CharSequenceContainsNoOpSearchBehaviour>

CharSequenceContainsRegexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int
fun search(searchIn: CharSequence, pattern: Pattern): Int

package ch.tutteli.atrium.assertions.iterable.contains

interface IterableContains

interface Checker : Contains.Checker, IterableContains.Checker
interface Creator<in T : Iterable<*>, in S> : Contains.Creator<T, S>, IterableContains.Creator<T, S>
interface SearchBehaviour : Contains.SearchBehaviour, IterableContains.SearchBehaviour

package ch.tutteli.atrium.assertions.iterable.contains.builders

abstract class IterableContainsAtLeastCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsAtLeastCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

abstract class IterableContainsAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsAtMostCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

open class IterableContainsBuilder<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : ContainsBuilder<T, S>, IterableContains.Builder<E, T, S>

IterableContainsBuilder(plant: AssertionPlant<T>, searchBehaviour: S)

abstract class IterableContainsButAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilderBase<E, T, S>, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

interface IterableContainsCheckerBuilder<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : ContainsCheckerBuilder<T, S, IterableContains.Checker, IterableContains.Builder<E, T, S>>, IterableContains.CheckerOption<E, T, S>
abstract class IterableContainsExactlyCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsExactlyCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

class IterableContainsNoOpCheckerBuilder<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNoOpCheckerBuilder(containsBuilder: IterableContainsBuilder<E, T, S>)
val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContainsBuilder<E, T, S>

abstract class IterableContainsNotCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNotCheckerBuilderBase(containsBuilder: IterableContainsBuilder<E, T, S>)
open val checkers: List<IterableContainsNotChecker>
open val containsBuilder: IterableContainsBuilder<E, T, S>

abstract class IterableContainsNotOrAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>

IterableContainsNotOrAtMostCheckerBuilderBase(times: Int, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int

package ch.tutteli.atrium.assertions.iterable.contains.checkers

class IterableContainsAtLeastChecker : IterableContainsChecker

IterableContainsAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

class IterableContainsAtMostChecker : IterableContainsChecker

IterableContainsAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

abstract class IterableContainsChecker : ContainsChecker, IterableContains.Checker

IterableContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)

class IterableContainsExactlyChecker : IterableContainsChecker

IterableContainsExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion

class IterableContainsNotChecker : IterableContains.Checker

IterableContainsNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

package ch.tutteli.atrium.assertions.iterable.contains.creators

fun <E : Any, T : Iterable<E>> _containsEntriesInAnyOrder(checker: IterableContainsCheckerBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E : Any, T : Iterable<E>> _containsEntriesInAnyOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E : Any, T : Iterable<E>> _containsEntriesInOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInAnyOrder(checker: IterableContainsCheckerBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInAnyOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
open class IterableContainsInAnyOrderEntriesAssertionCreator<E : Any, T : Iterable<E?>> : ContainsAssertionCreator<T, (AssertionPlant<E>.() -> Unit)?, IterableContains.Checker>, IterableContains.Creator<T, (AssertionPlant<E>.() -> Unit)?>

IterableContainsInAnyOrderEntriesAssertionCreator(searchBehaviour: IterableContainsInAnyOrderSearchBehaviour, checkers: List<IterableContains.Checker>)
protected fun createAssertionGroupForSearchCriteriaAssertions(assertions: List<Assertion>): AssertionGroup
protected fun searchAndCreateAssertion(subjectProvider: SubjectProvider<T>, searchCriterion: (AssertionPlant<E>.() -> Unit)?, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

class IterableContainsInAnyOrderObjectsAssertionCreator<S, T : Iterable<S>> : ContainsObjectsAssertionCreator<T, S, IterableContainsInAnyOrderSearchBehaviour, IterableContains.Checker>, IterableContains.Creator<T, S>

IterableContainsInAnyOrderObjectsAssertionCreator(searchBehaviour: IterableContainsInAnyOrderSearchBehaviour, checkers: List<IterableContains.Checker>)
protected val descriptionContains: DescriptionIterableAssertion
protected val descriptionNumberOfOccurrences: DescriptionIterableAssertion
protected fun search(subjectProvider: SubjectProvider<T>, searchCriterion: S): Int

abstract class IterableContainsInAnyOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : IterableContains.Creator<T, SC>

IterableContainsInAnyOrderOnlyAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected abstract fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: SC, list: MutableList<E?>): Pair<Boolean, Assertion>
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: SC, otherSearchCriteria: Array<out SC>): AssertionGroup
fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriteria: List<SC>): AssertionGroup

class IterableContainsInAnyOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, (AssertionPlant<E>.() -> Unit)?>

IterableContainsInAnyOrderOnlyEntriesAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: (AssertionPlant<E>.() -> Unit)?, list: MutableList<E?>): Pair<Boolean, Assertion>

class IterableContainsInAnyOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, E>

IterableContainsInAnyOrderOnlyObjectsAssertionCreator(searchBehaviour: IterableContainsInAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: E, list: MutableList<E?>): Pair<Boolean, Assertion>

abstract class IterableContainsInOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : IterableContains.Creator<T, SC>

IterableContainsInOrderOnlyAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createAssertionGroup(plant: AssertionPlant<T>, searchCriterion: SC, otherSearchCriteria: Array<out SC>): AssertionGroup
fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriteria: List<SC>): AssertionGroup
abstract fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: SC, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
abstract fun matches(actual: E?, searchCriterion: SC): Boolean

class IterableContainsInOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, (AssertionPlant<E>.() -> Unit)?>

IterableContainsInOrderOnlyEntriesAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: (AssertionPlant<E>.() -> Unit)?, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
fun matches(actual: E?, searchCriterion: (AssertionPlant<E>.() -> Unit)?): Boolean

class IterableContainsInOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, E>

IterableContainsInOrderOnlyObjectsAssertionCreator(searchBehaviour: IterableContainsInOrderOnlySearchBehaviour)
fun createEntryAssertion(iterableAsList: List<E?>, searchCriterion: E, template: ((Boolean) -> Assertion) -> AssertionGroup): AssertionGroup
fun matches(actual: E?, searchCriterion: E): Boolean

package ch.tutteli.atrium.assertions.iterable.contains.searchbehaviours

fun <E, T : Iterable<E>> _containsInAnyOrder(containsBuilder: IterableContainsBuilder<E, T, IterableContainsNoOpSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> _containsInAnyOrderOnly(containsBuilder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>
fun <E, T : Iterable<E>> _containsInOrder(containsBuilder: IterableContainsBuilder<E, T, IterableContainsNoOpSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInOrderSearchBehaviour>
fun <E, T : Iterable<E>> _containsInOrderOnly(containsBuilder: IterableContainsBuilder<E, T, IterableContainsInOrderSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>
open class IterableContainsInAnyOrderOnlySearchBehaviour : IterableContains.SearchBehaviour, InAnyOrderOnlySearchBehaviour

IterableContainsInAnyOrderOnlySearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInAnyOrderSearchBehaviour : IterableContains.SearchBehaviour, InAnyOrderSearchBehaviour

IterableContainsInAnyOrderSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInOrderOnlySearchBehaviour : IterableContains.SearchBehaviour, InOrderOnlySearchBehaviour

IterableContainsInOrderOnlySearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsInOrderSearchBehaviour : IterableContains.SearchBehaviour, InOrderSearchBehaviour

IterableContainsInOrderSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

open class IterableContainsNoOpSearchBehaviour : IterableContains.SearchBehaviour, NoOpSearchBehaviour

IterableContainsNoOpSearchBehaviour()

open class IterableContainsNotSearchBehaviour : IterableContainsInAnyOrderSearchBehaviour, NotSearchBehaviour

IterableContainsNotSearchBehaviour()
open fun decorateDescription(description: Translatable): Translatable

package ch.tutteli.atrium.assertions.throwable.thrown

interface ThrowableThrown

interface AbsentThrowableMessageProvider

abstract val message: RawString

interface Creator<TExpected : Throwable>

abstract fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrownBuilder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

package ch.tutteli.atrium.assertions.throwable.thrown.builders

class ThrowableThrownBuilder : ThrowableThrown.Builder

ThrowableThrownBuilder(assertionVerb: Translatable, act: () -> Unit, reporter: Reporter)
val act: () -> Unit
val assertionVerb: Translatable
val reporter: Reporter

package ch.tutteli.atrium.assertions.throwable.thrown.creators

class ThrowableThrownAssertionCreator<TExpected : Throwable> : ThrowableThrown.Creator<TExpected>

ThrowableThrownAssertionCreator(absentThrowableMessageProvider: ThrowableThrown.AbsentThrowableMessageProvider, failureHandler: AnyTypeTransformation.TypeTransformationFailureHandler<Throwable, TExpected>)
fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrownBuilder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

package ch.tutteli.atrium.assertions.throwable.thrown.providers

class TranslatableAsAbsentThrowableMessageProvider : ThrowableThrown.AbsentThrowableMessageProvider

TranslatableAsAbsentThrowableMessageProvider(translatable: Translatable)
val message: RawString

package ch.tutteli.atrium.checking

interface AssertionChecker

abstract fun check(assertionVerb: Translatable, representation: Any?, assertions: List<Assertion>): Unit
open fun check(assertionVerb: Translatable, representationProvider: () -> Any, assertions: List<Assertion>): Unit

package ch.tutteli.atrium.core

val coreFactory: CoreFactory
expect interface CoreFactory : CoreFactoryCommon

abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, nullRepresentation: Any = Text.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker, nullRepresentation: Any = Text.NULL): ReportingAssertionPlantNullable<T>

interface CoreFactoryCommon

abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subjectProvider: () -> T): CheckingAssertionPlant<T>
abstract fun <T> newCollectingAssertionContainer(maybeSubject: Option<T>): CollectingAssertionContainer<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newCollectingPlantNullable(subjectProvider: () -> T): CollectingAssertionPlantNullable<T>
abstract fun newDelegatingAssertionChecker(originalAssertionHolder: AssertionHolder): AssertionChecker
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
open fun <T> newDelegatingReportingAssertionContainer(originalAssertionHolder: AssertionHolder, maybeSubject: Option<T>): Expect<T>
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun newFeatureAssertionChecker(originalAssertionHolder: AssertionHolder): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newMultiAtriumErrorAdjuster(firstAdjuster: AtriumErrorAdjuster, secondAdjuster: AtriumErrorAdjuster, otherAdjusters: List<AtriumErrorAdjuster>): AtriumErrorAdjuster
abstract fun newNoOpAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade, atriumErrorAdjuster: AtriumErrorAdjuster): Reporter
abstract fun newRemoveAtriumFromAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newRemoveRunnerAtriumErrorAdjuster(): AtriumErrorAdjuster
open fun <T> newReportingAssertionContainer(assertionVerb: Translatable, maybeSubject: Option<T>, assertionChecker: AssertionChecker): ReportingAssertionContainer<T>
abstract fun <T> newReportingAssertionContainer(assertionCheckerDecorator: ReportingAssertionContainer.AssertionCheckerDecorator<T>): ReportingAssertionContainer<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: AssertionPlantWithCommonFields.CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
abstract fun <T> newReportingPlantNullable(commonFields: AssertionPlantWithCommonFields.CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextNextLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit

sealed class Either<out L, out R>

inline fun <T> fold(fL: (L) -> T, fR: (R) -> T): T
inline fun <T> map(f: (R) -> T): Either<L, T>
fun toOption(): Option<R>

@Target([AnnotationTarget.FUNCTION, AnnotationTarget.CLASS]) annotation class ExperimentalNewExpectTypes

ExperimentalNewExpectTypes()

val falseProvider: () -> Boolean
inline fun <L, R, T> Either<L, R>.flatMap(f: (R) -> Either<L, T>): Either<L, T>
inline fun <T> Option<T>.getOrElse(default: () -> T): T
kotlin.Function0

fun <T> (() -> T).evalOnce(): () -> T

data class Left<L> : Either<L, Nothing>

Left(l: L)
val l: L

fun <T> CoreFactoryCommon.newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, nullRepresentation: Any = Text.NULL): ReportingAssertionPlantNullable<T>
fun <T> CoreFactoryCommon.newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker, nullRepresentation: Any = Text.NULL): ReportingAssertionPlantNullable<T>
object None : Option<Nothing>
sealed class Option<out T>

inline fun filter(predicate: (T) -> Boolean): Option<T>
inline fun <R> flatMap(f: (T) -> Option<R>): Option<R>
inline fun <R> fold(default: () -> R, f: (T) -> R): R
fun isDefined(): Boolean
inline fun <R> map(f: (T) -> R): Option<R>
inline fun <T> someIf(predicate: Boolean, provider: () -> T): Option<T>

data class Right<R> : Either<Nothing, R>

Right(r: R)
val r: R

data class Some<T> : Option<T>

Some(value: T)
val value: T

val trueProvider: () -> Boolean

package ch.tutteli.atrium.core.migration

java.util.Locale

fun Locale.toAtriumLocale(): Locale

package ch.tutteli.atrium.core.polyfills

expect fun formatFloatingPointNumber(number: Number): String
expect fun getAtriumProperty(key: String): String?
java.lang.StringBuilder

expect fun StringBuilder.appendln(): StringBuilder

kotlin.reflect.KClass

expect fun <T : Any> KClass<T>.cast(any: Any?): T
expect val KClass<*>.fullName: String
expect fun <T : Any> KClass<out T>.fullName(obj: T): String

kotlin.String

expect fun String.format(locale: Locale, arg: Any, vararg otherArgs: Any): String
expect fun String.format(arg: Any, vararg otherArgs: Any): String

kotlin.Throwable

expect val Throwable.stackBacktrace: List<String>

expect fun <T : Any> loadServices(kClass: KClass<T>): Sequence<T>
expect fun <T : Any> loadSingleService(kClass: KClass<T>): T
expect fun setAtriumProperty(key: String, newValue: String): Unit
fun <T : Any> useSingleService(kClass: KClass<T>, itr: Iterator<T>): T

package ch.tutteli.atrium.creating

typealias Assert<T> = AssertionPlant<T>
interface AssertionContainer<T> : SubjectProvider<T>

abstract fun <I : Any> getImpl(kClass: KClass<I>, defaultFactory: () -> I): I
abstract val maybeSubject: Option<T>

interface AssertionHolder

abstract fun addAssertion(assertion: Assertion): AssertionHolder

interface AssertionPlant<out T : Any> : BaseAssertionPlant<T, AssertionPlant<T>>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun createAndAddAssertion(description: Translatable, expected: Any, test: () -> Boolean): AssertionPlant<T>

interface AssertionPlantNullable<out T> : BaseAssertionPlant<T, AssertionPlantNullable<T>>
interface AssertionPlantWithCommonFields<out T>

abstract val commonFields: AssertionPlantWithCommonFields.CommonFields<T>
class CommonFields<out T>

CommonFields(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any)
CommonFields(assertionVerb: Translatable, subjectProvider: () -> T, representationProvider: () -> Any?, assertionChecker: AssertionChecker, nullRepresentation: Any)
val assertionChecker: AssertionChecker
val assertionVerb: Translatable
fun check(assertions: List<Assertion>): Unit
val subjectProvider: () -> T

@DslMarker annotation class AssertMarker

AssertMarker()

interface BaseAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : SubjectProvider<T>

abstract fun addAssertion(assertion: Assertion): A
open val maybeSubject: Option<T>
abstract val subjectProvider: () -> T

interface BaseCollectingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>, out C : BaseCollectingAssertionPlant<T, A, C>> : BaseAssertionPlant<T, A>

abstract fun getAssertions(): List<Assertion>
abstract val subject: T

interface BaseReportingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : BaseAssertionPlant<T, A>, AssertionPlantWithCommonFields<T>
interface CheckingAssertionPlant<out T : Any> : AssertionPlant<T>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): CheckingAssertionPlant<T>
abstract fun allAssertionsHold(): Boolean

interface CollectingAssertionContainer<T> : Expect<T>

abstract fun addAssertion(assertion: Assertion): CollectingAssertionContainer<T>
abstract fun addAssertionsCreatedBy(assertionCreator: Expect<T>.() -> Unit): CollectingAssertionContainer<T>
abstract fun getAssertions(): List<Assertion>

interface CollectingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseCollectingAssertionPlant<T, AssertionPlant<T>, CollectingAssertionPlant<T>>

abstract fun addAssertionsCreatedBy(assertionCreator: AssertionPlant<T>.() -> Unit): CollectingAssertionPlant<T>

interface CollectingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseCollectingAssertionPlant<T, AssertionPlantNullable<T>, CollectingAssertionPlantNullable<T>>
interface CollectingExpect<T> : Expect<T>

abstract fun addAssertionsCreatedBy(assertionCreator: Expect<T>.() -> Unit): CollectingExpect<T>
abstract fun getAssertions(): List<Assertion>
operator fun <T> invoke(maybeSubject: Option<T>): CollectingExpect<T>

interface DelegatingExpect<T> : Expect<T>

operator fun <T> invoke(assertionHolder: AssertionHolder, maybeSubject: Option<T>): Expect<T>

enum class ErrorMessages : StringBasedTranslatable

AT_LEAST_ONE_ASSERTION_DEFINED
FORGOT_DO_DEFINE_ASSERTION
HINT_AT_LEAST_ONE_ASSERTION_DEFINED
SUBJECT_ACCESSED_TOO_EARLY
val value: String

interface Expect<T> : SubjectProvider<T>

abstract fun addAssertion(assertion: Assertion): Expect<T>
abstract fun addAssertionsCreatedBy(assertionCreator: Expect<T>.() -> Unit): Expect<T>
open fun createAndAddAssertion(description: String, expected: Any?, test: (T) -> Boolean): Expect<T>
open fun createAndAddAssertion(description: Translatable, expected: Any?, test: (T) -> Boolean): Expect<T>

interface ExpectInternal<T> : Expect<T>, AssertionContainer<T>
@DslMarker annotation class ExpectMarker

ExpectMarker()

interface FeatureExpect<T, R> : Expect<R>

operator fun <T, R> invoke(previousExpect: Expect<T>, maybeSubject: Option<R>, description: Translatable, assertions: List<Assertion>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>
operator fun <T, R> invoke(featureExpect: FeatureExpect<T, R>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>

data class FeatureExpectOptions<R>

FeatureExpectOptions(description: Translatable? = null, representationInsteadOfFeature: ((R) -> Any)? = null)
val description: Translatable?
fun merge(options: FeatureExpectOptions<R>): FeatureExpectOptions<R>
val representationInsteadOfFeature: ((R) -> Any)?

fun <R> FeatureExpectOptions(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): FeatureExpectOptions<R>
interface FeatureExpectOptionsChooser<R>

operator fun <R> invoke(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): FeatureExpectOptions<R>
open fun withDescription(description: String): Unit
abstract fun withDescription(description: Translatable): Unit
open fun withRepresentation(textRepresentation: String): Unit
abstract fun withRepresentation(representationProvider: (R) -> Any): Unit

sealed class MaybeSubject<out T>

object Absent : MaybeSubject<Nothing>

fun get(): Nothing

abstract fun get(): T
operator fun <T : Any> invoke(subject: T?): MaybeSubject<T>
data class Present<T> : MaybeSubject<T>

Present(subject: T)
fun get(): T
val subject: T

class PlantHasNoSubjectException : RuntimeException

PlantHasNoSubjectException()
PlantHasNoSubjectException(message: String)

interface ReportingAssertionContainer<T> : RootExpect<T>

abstract val assertionChecker: AssertionChecker
interface AssertionCheckerDecorator<T>

abstract val assertionChecker: AssertionChecker
abstract val assertionVerb: Translatable
abstract fun check(assertions: List<Assertion>): Unit
fun <T> create(assertionVerb: Translatable, maybeSubject: Option<T>, representation: Any?, assertionChecker: AssertionChecker): ReportingAssertionContainer.AssertionCheckerDecorator<T>
abstract val maybeSubject: Option<T>
abstract val representation: Any?

interface ReportingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseReportingAssertionPlant<T, AssertionPlant<T>>
interface ReportingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseReportingAssertionPlant<T, AssertionPlantNullable<T>>
interface RootExpect<T> : Expect<T>

operator fun <T> invoke(maybeSubject: Option<T>, assertionVerb: Translatable, expectOptions: RootExpectOptions<T>?): RootExpect<T>
operator fun <T> invoke(rootExpect: RootExpect<T>, expectOptions: RootExpectOptions<T>): RootExpect<T>

data class RootExpectOptions<T>

RootExpectOptions(assertionVerb: Translatable?, representationInsteadOfSubject: ((T) -> Any)?, reporter: Reporter?)
val assertionVerb: Translatable?
fun merge(options: RootExpectOptions<T>): RootExpectOptions<T>
val reporter: Reporter?
val representationInsteadOfSubject: ((T) -> Any)?

interface SubjectProvider<out T> : AssertionHolder

abstract val maybeSubject: Option<T>
abstract val subject: T

package ch.tutteli.atrium.domain.assertions.composers

val assertionComposer: AssertionComposer
interface AssertionComposer

abstract fun createDescriptiveWithFailureHint(description: Translatable, representation: Any, test: () -> Boolean, showHint: () -> Boolean, failureHintFactory: () -> Assertion): Assertion

package ch.tutteli.atrium.domain.builders

object AssertImpl : AssertImplCommon

inline val any: AnyAssertionsBuilder
inline val builder: AssertionBuilder
inline val charSequence: CharSequenceAssertionsBuilder
inline val collection: CollectionAssertionsBuilder
inline val collector: AssertionCollectorBuilder
inline val comparable: ComparableAssertionsBuilder
inline val coreFactory: CoreFactory
inline val feature: FeatureAssertionsBuilder
inline val floatingPoint: FloatingPointAssertionsBuilder
inline val iterable: IterableAssertionsBuilder
inline val list: ListAssertionsBuilder
inline val map: MapAssertionsBuilder
inline val pair: PairAssertionsBuilder
inline val throwable: ThrowableAssertionsBuilder

interface AssertImplCommon

abstract val any: AnyAssertionsBuilder
abstract val builder: AssertionBuilder
open fun <T, R : Any> changeSubject(originalPlant: BaseAssertionPlant<T, *>, subjectProvider: () -> R): AssertionPlant<R>
open fun <T, R : Any> changeSubject(originalAssertionCreator: Expect<T>, transformation: (T) -> R): Expect<R>
open fun <T, R> changeToNullableSubject(originalPlant: BaseAssertionPlant<T, *>, subjectProvider: () -> R): AssertionPlantNullable<R>
open fun <T, R : Any> changeToNullableSubject(originalAssertionCreator: Expect<T>, transformation: (T) -> R): Expect<R>
abstract val charSequence: CharSequenceAssertionsBuilder
abstract val collection: CollectionAssertionsBuilder
abstract val collector: AssertionCollectorBuilder
abstract val comparable: ComparableAssertionsBuilder
abstract val coreFactory: CoreFactory
abstract val feature: FeatureAssertionsBuilder
abstract val floatingPoint: FloatingPointAssertionsBuilder
abstract val iterable: IterableAssertionsBuilder
abstract val list: ListAssertionsBuilder
abstract val map: MapAssertionsBuilder
abstract val pair: PairAssertionsBuilder
abstract val throwable: ThrowableAssertionsBuilder

inline val AssertImpl.bigDecimal: BigDecimalAssertionsBuilder
inline val ExpectImpl.bigDecimal: BigDecimalAssertionsBuilder
inline val ExpectImpl.chronoLocalDate: ChronoLocalDateAssertionsBuilder
inline val ExpectImpl.chronoLocalDateTime: ChronoLocalDateTimeAssertionsBuilder
inline val ExpectImpl.chronoZonedDateTime: ChronoZonedDateTimeAssertionsBuilder
object ExpectImpl

inline val any: AnyAssertionsBuilder
inline val builder: AssertionBuilder
inline fun <T> changeSubject(originalExpect: Expect<T>): SubjectChangerBuilder.KindStep<T>
inline fun <T> changeSubject(originalAssertionContainer: SubjectProvider<T>): SubjectChangerBuilder.DeprecatedKindStep<T>
inline val charSequence: CharSequenceAssertionsBuilder
inline val collection: CollectionAssertionsBuilder
inline val collector: AssertionCollectorBuilder
inline val comparable: ComparableAssertionsBuilder
inline val feature: NewFeatureAssertionsBuilder
inline val floatingPoint: FloatingPointAssertionsBuilder
inline val fun0: Fun0AssertionsBuilder
inline val iterable: IterableAssertionsBuilder
inline val iterator: IteratorAssertionsBuilder
val list: ListAssertionsBuilder
inline val map: MapAssertionsBuilder
inline val pair: PairAssertionsBuilder
inline val throwable: ThrowableAssertionsBuilder

inline val ExpectImpl.localDate: LocalDateAssertionsBuilder
inline val ExpectImpl.localDateTime: LocalDateTimeAssertionsBuilder
inline val ExpectImpl.optional: OptionalAssertionsBuilder
inline val ExpectImpl.path: PathAssertionsBuilder
inline val ExpectImpl.zonedDateTime: ZonedDateTimeAssertionsBuilder

package ch.tutteli.atrium.domain.builders.creating

object AbsentThrowableMessageProviderFactoryBuilder : AbsentThrowableMessageProviderFactory

inline fun translatableBased(translatable: Translatable): ThrowableThrown.AbsentThrowableMessageProvider

object AnyAssertionsBuilder : AnyAssertions

inline fun <T, TSub : Any> isA(expect: Expect<T>, subType: KClass<TSub>): ChangedSubjectPostStep<T, TSub>
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
inline fun <T : Any> isNotNullBut(plant: AssertionPlantNullable<T?>, type: KClass<T>, expected: T): Assertion
inline fun <T> isNotSame(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T : Any> isNullable(plant: AssertionPlantNullable<T?>, type: KClass<T>, expectedOrNull: T?): Assertion
inline fun <T : Any> isNullIfNullGivenElse(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreatorOrNull: (AssertionPlant<T>.() -> Unit)?): Assertion
inline fun <T> isSame(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T> notToBe(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T> toBe(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T> toBeNull(subjectProvider: SubjectProvider<T>): Assertion
inline fun <T : Any> toBeNullIfNullGivenElse(expect: Expect<T?>, type: KClass<T>, noinline assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
inline val typeTransformation: AnyTypeTransformationAssertionsBuilder

object AnyTypeTransformationAssertionsBuilder : AnyTypeTransformationAssertions

inline fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: AnyTypeTransformation.FailureHandler<T, TSub>): Unit
inline val failureHandlers: AnyTypeTransformationFailureHandlerFactoryBuilder
inline fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Unit
inline fun <S : Any, T : Any> transform(parameterObject: AnyTypeTransformation.ParameterObject<S, T>, noinline canBeTransformed: (S) -> Boolean, noinline transform: (S) -> T, failureHandler: AnyTypeTransformation.FailureHandler<S, T>): Unit

object AnyTypeTransformationFailureHandlerFactoryBuilder : FailureHandlerFactory

inline fun <S : Any, T : Any> newExplanatory(): AnyTypeTransformation.FailureHandler<S, T>
inline fun <S : Any, T : Any> newExplanatoryWithHint(noinline showHint: () -> Boolean, noinline failureHintFactory: () -> Assertion): AnyTypeTransformation.FailureHandler<S, T>

object BigDecimalAssertionsBuilder : BigDecimalAssertions

inline fun <T : BigDecimal> isEqualIncludingScale(subjectProvider: SubjectProvider<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
inline fun <T : BigDecimal> isNotEqualIncludingScale(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T : BigDecimal> isNotNumericallyEqualTo(subjectProvider: SubjectProvider<T>, expected: T): Assertion
inline fun <T : BigDecimal> isNumericallyEqualTo(subjectProvider: SubjectProvider<T>, expected: T): Assertion

object CharSequenceAssertionsBuilder : CharSequenceAssertions

inline val contains: CharSequenceContainsAssertionsBuilder
inline fun <T : CharSequence> containsBuilder(subjectProvider: SubjectProvider<T>): CharSequenceContains.Builder<T, NoOpSearchBehaviour>
inline fun <T : CharSequence> containsNotBuilder(subjectProvider: SubjectProvider<T>): CharSequenceContains.Builder<T, NotSearchBehaviour>
inline fun endsNotWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
inline fun endsWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
inline fun isEmpty(subjectProvider: SubjectProvider<CharSequence>): Assertion
inline fun isNotBlank(subjectProvider: SubjectProvider<CharSequence>): Assertion
inline fun isNotEmpty(subjectProvider: SubjectProvider<CharSequence>): Assertion
inline fun <T : CharSequence> matches(expect: Expect<T>, expected: Regex): Assertion
inline fun <T : CharSequence> mismatches(expect: Expect<T>, expected: Regex): Assertion
inline fun startsNotWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
inline fun startsWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion

object CharSequenceContainsAssertionsBuilder : CharSequenceContainsAssertions

inline fun <T : CharSequence> defaultTranslationOf(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
inline fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
@JvmName("stringRegex") inline fun <T : CharSequence> regex(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): AssertionGroup
inline fun <T : CharSequence> regex(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<Regex>): AssertionGroup
inline fun <T : CharSequence> regexIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
inline val searchBehaviours: CharSequenceContainsSearchBehaviourFactoryBuilder
inline fun <T : CharSequence> values(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup
inline fun <T : CharSequence> valuesIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup

object CharSequenceContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory

inline fun <T : CharSequence> ignoringCase(containsBuilder: CharSequenceContains.Builder<T, NoOpSearchBehaviour>): CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>

object ChronoLocalDateAssertionsBuilder : ChronoLocalDateAssertions

inline fun <T : ChronoLocalDate> isAfter(expect: Expect<T>, expected: ChronoLocalDate): Assertion
inline fun <T : ChronoLocalDate> isAfterOrEquals(expect: Expect<T>, expected: ChronoLocalDate): Assertion
inline fun <T : ChronoLocalDate> isBefore(expect: Expect<T>, expected: ChronoLocalDate): Assertion
inline fun <T : ChronoLocalDate> isBeforeOrEquals(expect: Expect<T>, expected: ChronoLocalDate): Assertion
inline fun <T : ChronoLocalDate> isEqual(expect: Expect<T>, expected: ChronoLocalDate): Assertion

object ChronoLocalDateTimeAssertionsBuilder : ChronoLocalDateTimeAssertions

inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEquals(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEquals(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
inline fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion

object ChronoZonedDateTimeAssertionsBuilder : ChronoZonedDateTimeAssertions

inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
inline fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion

object CollectionAssertionsBuilder : CollectionAssertions

inline fun hasSize(plant: AssertionPlant<Collection<*>>, size: Int): Assertion
inline fun isEmpty(subjectProvider: SubjectProvider<Collection<*>>): Assertion
inline fun isNotEmpty(subjectProvider: SubjectProvider<Collection<*>>): Assertion
inline fun <T : Collection<*>> size(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun size(plant: AssertionPlant<Collection<*>>, noinline assertionCreator: Assert<Int>.() -> Unit): Assertion

object ComparableAssertionsBuilder : ComparableAssertions

inline fun <T1 : Comparable<T2>, T2> isEqualComparingTo(expect: Expect<T1>, expected: T2): Assertion
inline fun <T1 : Comparable<T2>, T2> isGreaterOrEquals(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
inline fun <T1 : Comparable<T2>, T2> isGreaterThan(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
inline fun <T1 : Comparable<T2>, T2> isLessOrEquals(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
inline fun <T1 : Comparable<T2>, T2> isLessThan(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion

object FeatureAssertionsBuilder : FeatureAssertions

inline val extractor: FeatureExtractor.DescriptionOption
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
@JvmName("safeReturnValueOf0") inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf0") inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf0") inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf1") inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf1") inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf1") inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf2") inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf2") inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf2") inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf3") inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf3") inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf3") inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf4") inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf4") inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf4") inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
@JvmName("safeReturnValueOf5") inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
@JvmName("safeReturnValueOf5") inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
@JvmName("safeReturnValueOf5") inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>

expect object FloatingPointAssertionsBuilder : FloatingPointAssertions

inline fun toBeWithErrorTolerance(subjectProvider: SubjectProvider<Float>, expected: Float, tolerance: Float): Assertion
inline fun toBeWithErrorTolerance(subjectProvider: SubjectProvider<Double>, expected: Double, tolerance: Double): Assertion
inline fun <T : BigDecimal> toBeWithErrorTolerance(subjectProvider: SubjectProvider<T>, expected: T, tolerance: T): Assertion

object Fun0AssertionsBuilder : Fun0Assertions

inline fun <R, T : () -> R> isNotThrowing(expect: Expect<T>): ChangedSubjectPostStep<*, R>
inline fun <TExpected : Throwable> isThrowing(expect: Expect<() -> Any?>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<*, TExpected>

object IterableAssertionsBuilder : IterableAssertions

inline fun <E : Any, T : Iterable<E?>> all(expect: Expect<T>, noinline assertionCreator: (Expect<E>.() -> Unit)?): Assertion
inline fun <E : Any> all(plant: AssertionPlant<Iterable<E?>>, noinline assertionCreator: (AssertionPlant<E>.() -> Unit)?): Assertion
inline val contains: IterableContainsAssertionsBuilder
inline fun <E, T : Iterable<E>> containsBuilder(subjectProvider: SubjectProvider<T>): IterableContains.Builder<E, T, NoOpSearchBehaviour>
inline fun <E, T : Iterable<E>> containsNotBuilder(subjectProvider: SubjectProvider<T>): IterableContains.Builder<E, T, NotSearchBehaviour>
inline fun <E, T : Iterable<E>> hasNext(expect: Expect<T>): Assertion
inline fun <E, T : Iterable<E>> hasNotNext(expect: Expect<T>): Assertion
inline fun <E : Comparable<E>, T : Iterable<E>> max(expect: Expect<T>): ExtractedFeaturePostStep<T, E>
inline fun <E : Comparable<E>, T : Iterable<E>> min(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

object IterableContainsAssertionsBuilder : IterableContainsAssertions

inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnlyWithAssert(builder: IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderWithAssert(checkerOption: IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGroupedWithAssert(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(AssertionPlant<E>.() -> Unit)?>>): Assertion
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyWithAssert(builder: IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
inline val searchBehaviours: IterableContainsSearchBehaviourFactoryBuilder
inline fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
inline fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
inline fun <E, T : Iterable<E>> valuesInOrderOnly(builder: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
inline fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

object IterableContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory

inline fun <E, T : Iterable<E>> inAnyOrder(builder: IterableContains.Builder<E, T, NoOpSearchBehaviour>): IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
inline fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>): IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
inline fun <E, T : Iterable<E>> inOrder(builder: IterableContains.Builder<E, T, NoOpSearchBehaviour>): IterableContains.Builder<E, T, InOrderSearchBehaviour>
inline fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContains.Builder<E, T, InOrderSearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
inline fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
inline fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

object IteratorAssertionsBuilder : IteratorAssertions

inline fun <E, T : Iterator<E>> hasNext(expect: Expect<T>): Assertion
inline fun <E, T : Iterator<E>> hasNotNext(expect: Expect<T>): Assertion

object ListAssertionsBuilder : ListAssertions

inline fun <E, T : List<E>> get(expect: Expect<T>, index: Int): ExtractedFeaturePostStep<T, E>
fun <T : Any> get(plant: AssertionPlant<List<T>>, index: Int): AssertionPlant<T>
inline fun <T : Any> get(plant: AssertionPlant<List<T>>, index: Int, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
fun <T> getNullable(plant: AssertionPlant<List<T>>, index: Int): AssertionPlantNullable<T>
inline fun <T> getNullable(plant: AssertionPlant<List<T>>, index: Int, noinline assertionCreator: AssertionPlantNullable<T>.() -> Unit): Assertion

object LocalDateAssertionsBuilder : LocalDateAssertions

inline fun <T : LocalDate> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : LocalDate> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
inline fun <T : LocalDate> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : LocalDate> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

object LocalDateTimeAssertionsBuilder : LocalDateTimeAssertions

inline fun <T : LocalDateTime> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : LocalDateTime> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
inline fun <T : LocalDateTime> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : LocalDateTime> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

object MapAssertionsBuilder : MapAssertions

inline fun <K, V, T : Map<out K, V>> contains(expect: Expect<T>, keyValuePairs: List<Pair<K, V>>): Assertion
inline fun <K, V> contains(plant: AssertionPlant<Map<out K, V>>, keyValuePairs: List<Pair<K, V>>): Assertion
inline fun <K> containsKey(subjectProvider: SubjectProvider<Map<out K, *>>, key: K): Assertion
inline fun <K, V : Any, T : Map<out K, V?>> containsKeyWithValueAssertions(expect: Expect<T>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
inline fun <K, V : Any> containsKeyWithValueAssertions(plant: AssertionPlant<Map<out K, V?>>, keyValues: List<Pair<K, (Assert<V>.() -> Unit)?>>): Assertion
inline fun <K> containsNotKey(subjectProvider: SubjectProvider<Map<out K, *>>, key: K): Assertion
inline val entry: MapEntryAssertionsBuilder
inline fun <K, V, T : Map<out K, V>> getExisting(expect: Expect<T>, key: K): ExtractedFeaturePostStep<T, V>
inline fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlant<V>
inline fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K, noinline assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
inline fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlantNullable<V>
inline fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
inline fun hasSize(plant: AssertionPlant<Map<*, *>>, size: Int): Assertion
inline fun isEmpty(subjectProvider: SubjectProvider<Map<*, *>>): Assertion
inline fun isNotEmpty(subjectProvider: SubjectProvider<Map<*, *>>): Assertion
inline fun <K> keys(plant: AssertionPlant<Map<out K, *>>, noinline assertionCreator: AssertionPlant<Set<K>>.() -> Unit): Assertion
inline fun <T : Map<*, *>> size(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <V> values(plant: AssertionPlant<Map<*, V>>, noinline assertionCreator: AssertionPlant<Collection<V>>.() -> Unit): Assertion

object MapEntryAssertionsBuilder : MapEntryAssertions

inline fun <K, V, T : Entry<K, V>> isKeyValue(expect: Expect<T>, key: K, value: V): Assertion
inline fun <K : Any, V : Any> isKeyValue(plant: AssertionPlant<Entry<K, V>>, key: K, value: V): Assertion
inline fun <K, T : Entry<K, *>> key(expect: Expect<T>): ExtractedFeaturePostStep<T, K>
inline fun <K : Any> key(plant: AssertionPlant<Entry<K, *>>, noinline assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
inline fun <K> nullableKey(plant: AssertionPlant<Entry<K, *>>, noinline assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
inline fun <V> nullableValue(plant: AssertionPlant<Entry<*, V>>, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
inline fun <V, T : Entry<*, V>> value(expect: Expect<T>): ExtractedFeaturePostStep<T, V>
inline fun <V : Any> value(plant: AssertionPlant<Entry<*, V>>, noinline assertionCreator: AssertionPlant<V>.() -> Unit): Assertion

object MetaFeatureBuilder

fun <T, R> create(expect: Expect<T>, description: String, provider: (T) -> R): MetaFeature<R>
fun <T, R> create(expect: Expect<T>, description: Translatable, provider: (T) -> R): MetaFeature<R>
fun <T, R> createSubjectBased(expect: Expect<T>, provider: (T) -> MetaFeature<R>): MetaFeature<R>
fun <R> f0(expect: Expect<*>, f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f1(expect: Expect<*>, f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f2(expect: Expect<*>, f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f3(expect: Expect<*>, f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f4(expect: Expect<*>, f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f5(expect: Expect<*>, f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <TProperty> property(property: KProperty0<TProperty>): MetaFeature<TProperty>

class MetaFeatureOption<T>

MetaFeatureOption(expect: Expect<T>)
fun <R> f(property: KProperty0<R>): MetaFeature<R>
fun <R> f(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> f0(f: KFunction0<R>): MetaFeature<R>
fun <A1, R> f1(f: KFunction1<A1, R>, a1: A1): MetaFeature<R>
fun <A1, A2, R> f2(f: KFunction2<A1, A2, R>, a1: A1, a2: A2): MetaFeature<R>
fun <A1, A2, A3, R> f3(f: KFunction3<A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): MetaFeature<R>
fun <A1, A2, A3, A4, R> f4(f: KFunction4<A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): MetaFeature<R>
fun <A1, A2, A3, A4, A5, R> f5(f: KFunction5<A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): MetaFeature<R>
fun <R> p(property: KProperty0<R>): MetaFeature<R>

object NewFeatureAssertionsBuilder : NewFeatureAssertions

inline fun <T> extractor(originalAssertionContainer: Expect<T>): FeatureExtractorBuilder.DescriptionStep<T>
fun <T, R> f0(expect: Expect<T>, f: KFunction1<T, R>): ExtractedFeaturePostStep<T, R>
fun <T, A1, R> f1(expect: Expect<T>, f: KFunction2<T, A1, R>, a1: A1): ExtractedFeaturePostStep<T, R>
fun <T, A1, A2, R> f2(expect: Expect<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): ExtractedFeaturePostStep<T, R>
fun <T, A1, A2, A3, R> f3(expect: Expect<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): ExtractedFeaturePostStep<T, R>
fun <T, A1, A2, A3, A4, R> f4(expect: Expect<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): ExtractedFeaturePostStep<T, R>
fun <T, A1, A2, A3, A4, A5, R> f5(expect: Expect<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): ExtractedFeaturePostStep<T, R>
inline fun <T, R> genericFeature(expect: Expect<T>, metaFeature: MetaFeature<R>): ExtractedFeaturePostStep<T, R>
fun <T, R> genericSubjectBasedFeature(expect: Expect<T>, provider: (T) -> MetaFeature<R>): ExtractedFeaturePostStep<T, R>
fun <T, R> manualFeature(expect: Expect<T>, description: String, provider: T.() -> R): ExtractedFeaturePostStep<T, R>
fun <T, R> manualFeature(expect: Expect<T>, description: Translatable, provider: T.() -> R): ExtractedFeaturePostStep<T, R>
inline val meta: MetaFeatureBuilder
fun <T, TProperty> property(expect: Expect<T>, property: KProperty1<in T, TProperty>): ExtractedFeaturePostStep<T, TProperty>

object OptionalAssertionsBuilder : OptionalAssertions

inline fun <T : Optional<*>> isEmpty(expect: Expect<T>): Assertion
inline fun <E, T : Optional<E>> isPresent(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

object PairAssertionsBuilder : PairAssertions

inline fun <K, T : Pair<K, *>> first(expect: Expect<T>): ExtractedFeaturePostStep<T, K>
inline fun <K : Any> first(plant: AssertionPlant<Pair<K, *>>, noinline assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
inline fun <K> nullableFirst(plant: AssertionPlant<Pair<K, *>>, noinline assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
inline fun <V> nullableSecond(plant: AssertionPlant<Pair<*, V>>, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
inline fun <V, T : Pair<*, V>> second(expect: Expect<T>): ExtractedFeaturePostStep<T, V>
inline fun <V : Any> second(plant: AssertionPlant<Pair<*, V>>, noinline assertionCreator: AssertionPlant<V>.() -> Unit): Assertion

object PathAssertionsBuilder : PathAssertions

inline fun <T : Path> endsNotWith(expect: Expect<T>, expected: Path): Assertion
inline fun <T : Path> endsWith(expect: Expect<T>, expected: Path): Assertion
inline fun <T : Path> exists(expect: Expect<T>): Assertion
inline fun <T : Path> existsNot(expect: Expect<T>): Assertion
inline fun <T : Path> extension(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
inline fun <T : Path> fileName(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
inline fun <T : Path> fileNameWithoutExtension(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
inline fun <T : Path> hasSameBinaryContentAs(expect: Expect<T>, targetPath: Path): Assertion
inline fun <T : Path> hasSameTextualContentAs(expect: Expect<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
inline fun <T : Path> isDirectory(expect: Expect<T>): Assertion
inline fun <T : Path> isReadable(expect: Expect<T>): Assertion
inline fun <T : Path> isRegularFile(expect: Expect<T>): Assertion
inline fun <T : Path> isWritable(expect: Expect<T>): Assertion
inline fun <T : Path> parent(expect: Expect<T>): ExtractedFeaturePostStep<T, Path>
inline fun <T : Path> resolve(expect: Expect<T>, other: String): ExtractedFeaturePostStep<T, Path>
inline fun <T : Path> startsNotWith(expect: Expect<T>, expected: Path): Assertion
inline fun <T : Path> startsWith(expect: Expect<T>, expected: Path): Assertion

class PleaseUseReplacementException : Exception

PleaseUseReplacementException(reason: String)

object ThrowableAssertionsBuilder : ThrowableAssertions

inline fun <TExpected : Throwable> cause(expect: Expect<out Throwable>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<Throwable?, TExpected>
inline val thrown: ThrowableThrownAssertionsBuilder
inline fun thrownBuilder(assertionVerb: Translatable, noinline act: () -> Unit, reporter: Reporter): ThrowableThrown.Builder

object ThrowableThrownAssertionsBuilder : ThrowableThrownAssertions

inline fun nothingThrown(throwableThrownBuilder: ThrowableThrown.Builder): Unit
inline val providers: AbsentThrowableMessageProviderFactoryBuilder
inline fun <TExpected : Throwable> toBe(throwableThrownBuilder: ThrowableThrown.Builder, expectedType: KClass<TExpected>, noinline assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

object ZonedDateTimeAssertionsBuilder : ZonedDateTimeAssertions

inline fun <T : ZonedDateTime> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : ZonedDateTime> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
inline fun <T : ZonedDateTime> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
inline fun <T : ZonedDateTime> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

package ch.tutteli.atrium.domain.builders.creating.basic.contains

fun <T : Any, B : Contains.Builder<T, *>> Contains.CheckerOption<T, *, *, B>.addAssertion(assertion: Assertion): Expect<T>
fun <E, T : Iterable<E>, S : IterableContains.SearchBehaviour> IterableContains.Builder<E, T, S>.addAssertion(assertion: Assertion): Expect<T>
fun <T : Any, B : Contains.Builder<T, *>> Contains.CheckerOption<T, *, *, B>.addAssertionForAssert(assertion: Assertion): Assert<T>
fun <E, T : Iterable<E>, S : IterableContains.SearchBehaviour> IterableContains.Builder<E, T, S>.addAssertionForAssert(assertion: Assertion): Assert<T>

package ch.tutteli.atrium.domain.builders.creating.changers

interface FeatureExtractorBuilder

fun <T> create(originalAssertionContainer: Expect<T>): FeatureExtractorBuilder.DescriptionStep<T>
interface DescriptionStep<T>

fun <T> create(originalAssertionContainer: Expect<T>): FeatureExtractorBuilder.DescriptionStep<T>
open fun methodCall(methodName: String, vararg arguments: Any?): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
abstract val originalAssertionContainer: Expect<T>
open fun withDescription(description: String): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
abstract fun withDescription(translatable: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>

interface FeatureExtractionStep<T>

fun <T> create(originalAssertionContainer: Expect<T>, description: Translatable, representationForFailure: Any): FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract val description: Translatable
abstract val originalAssertionContainer: Expect<T>
abstract val representationForFailure: Any
abstract fun <R> withFeatureExtraction(extraction: (subject: T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>

interface FinalStep<T, R>

abstract fun build(): ExtractedFeaturePostStep<T, R>
fun <T, R> create(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>, featureOptions: FeatureOptions<R>?): FeatureExtractorBuilder.FinalStep<T, R>
abstract val featureExtraction: (T) -> Option<R>
abstract val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract val featureOptions: FeatureOptions<R>?

interface OptionsChooser<R>

fun <R> createAndBuild(configuration: FeatureExtractorBuilder.OptionsChooser<R>.() -> Unit): FeatureOptions<R>
open fun withDescription(description: String): Unit
abstract fun withDescription(description: Translatable): Unit
open fun withRepresentation(textRepresentation: String): Unit
abstract fun withRepresentation(representationProvider: (R) -> Any): Unit

interface OptionsStep<T, R>

fun <T, R> create(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>
abstract val featureExtraction: (T) -> Option<R>
abstract val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
open fun withOptions(configuration: FeatureExtractorBuilder.OptionsChooser<R>.() -> Unit): FeatureExtractorBuilder.FinalStep<T, R>
abstract fun withOptions(expectOptions: FeatureOptions<R>): FeatureExtractorBuilder.FinalStep<T, R>
abstract fun withoutOptions(): FeatureExtractorBuilder.FinalStep<T, R>

interface RepresentationInCaseOfFailureStep<T>

fun <T> create(originalAssertionContainer: Expect<T>, description: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
abstract val description: Translatable
abstract val originalAssertionContainer: Expect<T>
open fun withRepresentationForFailure(representationProvider: () -> Any?): FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract fun withRepresentationForFailure(representation: Any): FeatureExtractorBuilder.FeatureExtractionStep<T>

data class FeatureOptions<R>

FeatureOptions(description: Translatable? = null, representationInsteadOfFeature: ((R) -> Any)? = null)
val description: Translatable?
fun merge(options: FeatureOptions<R>): FeatureOptions<R>
val representationInsteadOfFeature: ((R) -> Any)?
fun toFeatureExpectOptions(): FeatureExpectOptions<R>

fun <R> FeatureOptions(configuration: FeatureExtractorBuilder.OptionsChooser<R>.() -> Unit): FeatureOptions<R>
interface SubjectChangerBuilder

fun <T> create(expect: Expect<T>): SubjectChangerBuilder.KindStep<T>
fun <T> create(originalPlant: SubjectProvider<T>): SubjectChangerBuilder.DeprecatedKindStep<T>
interface DeprecatedKindStep<T>

abstract val originalPlant: SubjectProvider<T>
open fun <R : Any> unreported(transformation: (T) -> R): Assert<R>
open fun <R> unreportedNullable(transformation: (T) -> R): AssertionPlantNullable<R>

interface DescriptionRepresentationStep<T>

fun <T> create(originalAssertionContainer: Expect<T>): SubjectChangerBuilder.DescriptionRepresentationStep<T>
open fun <TSub : Any> downCastTo(subType: KClass<TSub>): SubjectChangerBuilder.FailureHandlerOption<T, TSub>
abstract val originalExpect: Expect<T>
open fun withDescriptionAndRepresentation(description: String, representation: Any?): SubjectChangerBuilder.TransformationStep<T>
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): SubjectChangerBuilder.TransformationStep<T>

interface FailureHandlerOption<T, R>

open fun build(): ChangedSubjectPostStep<T, R>
fun <T, R> create(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerOption<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>
abstract fun withDefaultFailureHandler(): SubjectChangerBuilder.FinalStep<T, R>
abstract fun withFailureHandler(failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
open fun <R1> withFailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1): SubjectChangerBuilder.FinalStep<T, R>

interface FinalStep<T, R>

abstract fun build(): ChangedSubjectPostStep<T, R>
fun <T, R> create(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
abstract val failureHandler: SubjectChanger.FailureHandler<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>

interface KindStep<T>

abstract val originalExpect: Expect<T>
abstract fun reportBuilder(): SubjectChangerBuilder.DescriptionRepresentationStep<T>
open fun <R> unreported(transformation: (T) -> R): Expect<R>

interface TransformationStep<T>

fun <T> create(originalAssertionContainer: Expect<T>, description: Translatable, representation: Any): SubjectChangerBuilder.TransformationStep<T>
abstract val description: Translatable
abstract val originalExpect: Expect<T>
abstract val representation: Any
abstract fun <R> withTransformation(transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerOption<T, R>

package ch.tutteli.atrium.domain.builders.creating.charsequence.contains.builders

abstract class AtLeastCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

AtLeastCheckerOptionBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class AtMostCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

AtMostCheckerOptionBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class ButAtMostCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<T, S>, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class ExactlyCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

ExactlyCheckerOptionBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

abstract class NotCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>

NotCheckerOptionBase(containsBuilder: CharSequenceContains.Builder<T, S>)
open val checkers: List<CharSequenceContains.Checker>
open val containsBuilder: CharSequenceContains.Builder<T, S>

abstract class NotOrAtMostCheckerOptionBase<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerOption<T, S>

NotOrAtMostCheckerOptionBase(times: Int, containsBuilder: CharSequenceContains.Builder<T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<CharSequenceContains.Checker>
val containsBuilder: CharSequenceContains.Builder<T, S>
val times: Int

interface WithTimesCheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerOption<T, S>

abstract val times: Int

package ch.tutteli.atrium.domain.builders.creating.collectors

object AssertionCollectorBuilder : AssertionCollector

inline fun <T> collect(maybeSubject: Option<T>, noinline assertionCreator: Expect<T>.() -> Unit): Assertion
inline fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(noinline subjectProvider: () -> T, noinline collectingPlantFactory: (() -> T) -> C, noinline assertionCreator: C.() -> Unit): AssertionGroup
inline fun <T> collectForComposition(maybeSubject: Option<T>, noinline assertionCreator: Expect<T>.() -> Unit): List<Assertion>
inline fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, noinline subjectProvider: () -> T, noinline collectingPlantFactory: (() -> T) -> C, noinline assertionCreator: C.() -> Unit): AssertionGroup
inline val forExplanation: ExplainingAssertionCollectorOption

fun <T, G : ExplanatoryAssertionGroupType, R> AssertionsOption<G, R>.collectAssertions(expect: Expect<T>, assertionCreator: Expect<T>.() -> Unit): R
fun <T, G : ExplanatoryAssertionGroupType, R> AssertionsOption<G, R>.collectAssertions(maybeSubject: Option<T>, assertionCreator: Expect<T>.() -> Unit): R
object ExplainingAssertionCollectorOption

inline val doNotThrowIfNoAssertionIsCollected: NonThrowingAssertionCollectorForExplanation
inline val throwIfNoAssertionIsCollected: ThrowingAssertionCollectorForExplanation

package ch.tutteli.atrium.domain.builders.creating.iterable.contains.builders

abstract class AtLeastCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

AtLeastCheckerOptionBase(times: Int, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, atLeastCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

abstract class AtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

AtMostCheckerOptionBase(times: Int, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

abstract class ButAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<E, T, S>, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

abstract class ExactlyCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

ExactlyCheckerOptionBase(times: Int, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, exactlyCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

abstract class NotCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>

NotCheckerOptionBase(containsBuilder: IterableContains.Builder<E, T, S>)
open val checkers: List<IterableContains.Checker>
open val containsBuilder: IterableContains.Builder<E, T, S>

abstract class NotOrAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : WithTimesCheckerOption<E, T, S>

NotOrAtMostCheckerOptionBase(times: Int, containsBuilder: IterableContains.Builder<E, T, S>, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String)
open val checkers: List<IterableContains.Checker>
val containsBuilder: IterableContains.Builder<E, T, S>
val times: Int

interface WithTimesCheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : IterableContains.CheckerOption<E, T, S>

abstract val times: Int

package ch.tutteli.atrium.domain.builders.kotlin_1_3

inline val ExpectImpl.result: ResultAssertionsBuilder

package ch.tutteli.atrium.domain.builders.kotlin_1_3.creating

object ResultAssertionsBuilder : ResultAssertions

fun <TExpected : Throwable> isFailure(expect: Expect<out Result<*>>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<Throwable?, TExpected>
inline fun <E, T : Result<E>> isSuccess(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

package ch.tutteli.atrium.domain.builders.migration

fun <T : Any> Expect<T>.asAssert(): Assert<T>
fun <T : Any> Expect<T>.asAssert(assertionCreator: Assert<T>.() -> Unit): Assert<T>
fun <T, A : BaseAssertionPlant<T, *>> A.asExpect(): Expect<T>
fun <T : Any, A : BaseAssertionPlant<T, *>> A.asExpect(assertionCreator: Expect<T>.() -> Unit): A
fun <T : Any> asExpectGroup(group: Group<(Assert<T>.() -> Unit)?>): Group<(Expect<T>.() -> Unit)?>
fun <T : Any> asSubExpect(assertionCreatorOrNull: (Assert<T>.() -> Unit)?): (Expect<T>.() -> Unit)?

package ch.tutteli.atrium.domain.builders.reporting

data class AssertionFormatterChosenOptions

AssertionFormatterChosenOptions(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator)
val assertionFormatterFacade: AssertionFormatterFacade
val objectFormatter: ObjectFormatter
val translator: Translator

interface AssertionFormatterControllerOption

fun create(objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatterControllerOption
abstract val objectFormatter: ObjectFormatter
abstract val translator: Translator
abstract fun withAssertionFormatterController(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacadeOption
abstract fun withDefaultAssertionFormatterController(): AssertionFormatterFacadeOption

interface AssertionFormatterFacadeOption

abstract val assertionFormatterController: AssertionFormatterController
fun create(assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatterFacadeOption
abstract val objectFormatter: ObjectFormatter
abstract val translator: Translator
abstract fun withAssertionFormatterFacade(factory: (AssertionFormatterController) -> AssertionFormatterFacade): AssertionPairFormatterOption
abstract fun withDefaultAssertionFormatterFacade(): AssertionPairFormatterOption

interface AssertionPairFormatterOption

fun create(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatterOption
fun create(options: AssertionFormatterChosenOptions): AssertionPairFormatterOption
abstract val options: AssertionFormatterChosenOptions
abstract fun withTextAssertionPairFormatter(factory: (ObjectFormatter, Translator) -> AssertionPairFormatter): TextAssertionFormatterOption
open fun withTextNextLineAssertionPairFormatter(): TextAssertionFormatterOption
open fun withTextSameLineAssertionPairFormatter(): TextAssertionFormatterOption

interface AtriumErrorAdjusterCommonOption<R : Any>

abstract fun withAtriumErrorAdjuster(adjuster: AtriumErrorAdjuster): R
abstract fun withRemoveAtriumFromAtriumErrorAdjuster(): R
abstract fun withRemoveRunnerAtriumErrorAdjuster(): R

interface AtriumErrorAdjusterOption : AtriumErrorAdjusterCommonOption<ReporterOption>

abstract val assertionFormatterFacade: AssertionFormatterFacade
fun create(assertionFormatterFacade: AssertionFormatterFacade): AtriumErrorAdjusterOption
abstract fun withCustomReporter(factory: (AssertionFormatterFacade) -> Reporter): ReporterBuilderFinalStep
open fun withDefaultAtriumErrorAdjusters(): ReporterOption
abstract fun withMultipleAdjusters(configure: MultipleAdjustersOption.() -> Unit): ReporterOption
abstract fun withNoOpAtriumErrorAdjuster(): ReporterOption
abstract fun withOnlyFailureReporter(): ReporterBuilderFinalStep

interface ExpectBuilder

interface AssertionVerbStep<T>

abstract val maybeSubject: Option<T>
open fun withVerb(verb: String): ExpectBuilder.OptionsStep<T>
abstract fun withVerb(verb: Translatable): ExpectBuilder.OptionsStep<T>

interface FinalStep<T>

abstract val assertionVerb: Translatable
abstract fun build(): RootExpect<T>
fun <T> create(maybeSubject: Option<T>, assertionVerb: Translatable, options: ExpectOptions<T>?): ExpectBuilder.FinalStep<T>
abstract val maybeSubject: Option<T>
abstract val options: ExpectOptions<T>?

fun <T> forSubject(subject: T): ExpectBuilder.AssertionVerbStep<T>
interface OptionsChooser<T>

fun <T> createAndBuild(configuration: ExpectBuilder.OptionsChooser<T>.() -> Unit): ExpectOptions<T>
abstract fun withReporter(reporter: Reporter): Unit
open fun withRepresentation(textRepresentation: String): Unit
abstract fun withRepresentation(representationProvider: (T) -> Any): Unit
open fun withVerb(verb: String): Unit
abstract fun withVerb(verb: Translatable): Unit

interface OptionsStep<T>

abstract val assertionVerb: Translatable
fun <T> create(maybeSubject: Option<T>, assertionVerb: Translatable): ExpectBuilder.OptionsStep<T>
abstract val maybeSubject: Option<T>
open fun withOptions(configuration: ExpectBuilder.OptionsChooser<T>.() -> Unit): ExpectBuilder.FinalStep<T>
abstract fun withOptions(expectOptions: ExpectOptions<T>): ExpectBuilder.FinalStep<T>
abstract fun withoutOptions(): ExpectBuilder.FinalStep<T>

data class ExpectOptions<T>

ExpectOptions(assertionVerb: Translatable? = null, representationInsteadOfSubject: ((T) -> Any)? = null, reporter: Reporter? = null)
val assertionVerb: Translatable?
fun merge(options: ExpectOptions<T>): ExpectOptions<T>
val reporter: Reporter?
val representationInsteadOfSubject: ((T) -> Any)?
fun toRootExpectOptions(): RootExpectOptions<T>

fun <T> ExpectOptions(configuration: ExpectBuilder.OptionsChooser<T>.() -> Unit): ExpectOptions<T>
interface LocaleOrderDeciderOption

fun create(translationSupplier: TranslationSupplier): LocaleOrderDeciderOption
abstract val translationSupplier: TranslationSupplier
abstract fun withDefaultLocaleOrderDecider(): TranslatorOption
abstract fun withLocaleOrderDecider(localeOrderDecider: LocaleOrderDecider): TranslatorOption

interface MultipleAdjustersOption : AtriumErrorAdjusterCommonOption<Unit>

abstract val adjusters: List<AtriumErrorAdjuster>
fun create(): MultipleAdjustersOption
abstract fun withAtriumErrorAdjuster(adjuster: AtriumErrorAdjuster): Unit
abstract fun withRemoveAtriumFromAtriumErrorAdjuster(): Unit
abstract fun withRemoveRunnerAtriumErrorAdjuster(): Unit

@DslMarker annotation class MultipleAdjustersOptionMarker

MultipleAdjustersOptionMarker()

interface ObjectFormatterOption

fun create(translator: Translator): ObjectFormatterOption
abstract val translator: Translator
abstract fun withDetailedObjectFormatter(): AssertionFormatterControllerOption
abstract fun withObjectFormatter(factory: (Translator) -> ObjectFormatter): AssertionFormatterControllerOption

val reporterBuilder: ReporterBuilder
expect interface ReporterBuilder : ReporterBuilderCommon

fun create(): ReporterBuilder
open fun withoutTranslations(primaryLocale: Locale = java.util.Locale.getDefault()): ObjectFormatterOption

interface ReporterBuilderCommon

abstract fun withDefaultTranslationSupplier(): LocaleOrderDeciderOption
abstract fun withoutTranslations(primaryLocale: Locale): ObjectFormatterOption
open fun withoutTranslationsUseDefaultLocale(): ObjectFormatterOption
abstract fun withTranslationSupplier(translationSupplier: TranslationSupplier): LocaleOrderDeciderOption
abstract fun withTranslator(translator: Translator): ObjectFormatterOption

interface ReporterBuilderFinalStep

abstract fun build(): Reporter
fun create(factory: () -> Reporter): ReporterBuilderFinalStep

interface ReporterOption

abstract val assertionFormatterFacade: AssertionFormatterFacade
abstract val atriumErrorAdjuster: AtriumErrorAdjuster
fun create(assertionFormatterFacade: AssertionFormatterFacade, atriumErrorAdjuster: AtriumErrorAdjuster): ReporterOption
abstract fun withCustomReporter(factory: (AssertionFormatterFacade, AtriumErrorAdjuster) -> Reporter): ReporterBuilderFinalStep
abstract fun withOnlyFailureReporter(): ReporterBuilderFinalStep

expect interface TextAssertionFormatterOption : TextAssertionFormatterOptionCommon

fun create(options: AssertionFormatterChosenOptions, assertionPairFormatter: AssertionPairFormatter): TextAssertionFormatterOption
open fun withDefaultTextCapabilities(vararg bulletPoints: Pair<Class<out BulletPointIdentifier>, String>): ReporterOption

interface TextAssertionFormatterOptionCommon

abstract val assertionPairFormatter: AssertionPairFormatter
abstract val options: AssertionFormatterChosenOptions
abstract fun withTextAssertionFormatter(factory: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter, vararg otherFactories: (AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter): AtriumErrorAdjusterOption
abstract fun withTextCapabilities(vararg bulletPoints: Pair<KClass<out BulletPointIdentifier>, String>): AtriumErrorAdjusterOption

expect interface TranslatorOption : TranslatorOptionCommon

open fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ObjectFormatterOption

interface TranslatorOptionCommon

abstract val localeOrderDecider: LocaleOrderDecider
abstract val translationSupplier: TranslationSupplier
abstract fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ObjectFormatterOption
abstract fun withTranslator(factory: (TranslationSupplier, LocaleOrderDecider) -> Translator): ObjectFormatterOption

package ch.tutteli.atrium.domain.builders.utils

class ArgumentMapperBuilder<out T>

ArgumentMapperBuilder(first: T, others: Array<out T>)
val first: T
val others: Array<out T>
inline fun <reified R> to(mapper: (T) -> R): Pair<R, Array<out R>>
inline fun <reified R : Any> toAssert(crossinline assertionCreator: Assert<R>.(T) -> Unit): Pair<Assert<R>.() -> Unit, Array<Assert<R>.() -> Unit>>
inline fun <reified R> toAssertionPlantNullable(crossinline assertionCreator: AssertionPlantNullable<R>.(T) -> Unit): Pair<AssertionPlantNullable<R>.() -> Unit, Array<AssertionPlantNullable<R>.() -> Unit>>
inline fun <reified R> toExpect(crossinline assertionCreator: Expect<R>.(T) -> Unit): Pair<Expect<R>.() -> Unit, Array<Expect<R>.() -> Unit>>

class ArgumentToNullOrMapperBuilder<T : Any>

ArgumentToNullOrMapperBuilder(argumentMapperBuilder: ArgumentMapperBuilder<T?>)
val argumentMapperBuilder: ArgumentMapperBuilder<T?>
inline fun <R : Any> toAssert(crossinline assertionCreator: Assert<R>.(T) -> Unit): Pair<(Assert<R>.() -> Unit)?, Array<(Assert<R>.() -> Unit)?>>
inline fun <R : Any> toExpect(crossinline assertionCreator: Expect<R>.(T) -> Unit): Pair<(Expect<R>.() -> Unit)?, Array<(Expect<R>.() -> Unit)?>>

interface Group<out T>

abstract fun toList(): List<T>

fun <T> groupsToList(firstGroup: Group<T>, secondGroup: Group<T>, otherGroups: Array<out Group<T>>): List<List<T>>
interface GroupWithNullableEntries<out T> : Group<T>
interface GroupWithoutNullableEntries<out T> : Group<T>
inline fun <reified T> iterableLikeToIterable(iterableLike: IterableLike): Iterable<T>
inline fun <reified T> iterableToPair(iterable: Iterable<T>): Pair<T, Array<out T>>
fun <T> mapArguments(first: T, others: Array<out T>): ArgumentMapperBuilder<T>
inline fun <T, reified R> mapArguments(first: T, others: Array<out T>, mapper: (T) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Byte, others: ByteArray): ArgumentMapperBuilder<Byte>
inline fun <reified R> mapArguments(first: Byte, others: ByteArray, mapper: (Byte) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Char, others: CharArray): ArgumentMapperBuilder<Char>
inline fun <reified R> mapArguments(first: Char, others: CharArray, mapper: (Char) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Short, others: ShortArray): ArgumentMapperBuilder<Short>
inline fun <reified R> mapArguments(first: Short, others: ShortArray, mapper: (Short) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Int, others: IntArray): ArgumentMapperBuilder<Int>
inline fun <reified R> mapArguments(first: Int, others: IntArray, mapper: (Int) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Long, others: LongArray): ArgumentMapperBuilder<Long>
inline fun <reified R> mapArguments(first: Long, others: LongArray, mapper: (Long) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Float, others: FloatArray): ArgumentMapperBuilder<Float>
inline fun <reified R> mapArguments(first: Float, others: FloatArray, mapper: (Float) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Double, others: DoubleArray): ArgumentMapperBuilder<Double>
inline fun <reified R> mapArguments(first: Double, others: DoubleArray, mapper: (Double) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Boolean, others: BooleanArray): ArgumentMapperBuilder<Boolean>
inline fun <reified R> mapArguments(first: Boolean, others: BooleanArray, mapper: (Boolean) -> R): Pair<R, Array<out R>>
inline fun <T> nullable(t: T): T?
inline fun <T> nullable(t: KFunction0<T>): KFunction0<T?>
@JvmName("nullable1") inline fun <T1, R> nullable(t: KFunction1<T1, R>): KFunction1<T1, R?>
@JvmName("nullable2") inline fun <T1, T2, R> nullable(t: KFunction2<T1, T2, R>): KFunction2<T1, T2, R?>
@JvmName("nullable3") inline fun <T1, T2, T3, R> nullable(t: KFunction3<T1, T2, T3, R>): KFunction3<T1, T2, T3, R?>
@JvmName("nullable4") inline fun <T1, T2, T3, T4, R> nullable(t: KFunction4<T1, T2, T3, T4, R>): KFunction4<T1, T2, T3, T4, R?>
@JvmName("nullable5") inline fun <T1, T2, T3, T4, T5, R> nullable(t: KFunction5<T1, T2, T3, T4, T5, R>): KFunction5<T1, T2, T3, T4, T5, R?>
inline fun <T> nullableContainer(iterable: Iterable<T>): Iterable<T?>
inline fun <T> nullableContainer(arr: Array<out T>): Array<out T?>
inline fun <K, V : Any> nullableKeyMap(map: Map<out K, V>): Map<out K?, V>
inline fun <K, V> nullableKeyValueMap(map: Map<out K, V>): Map<out K?, V?>
inline fun <K : Any, V> nullableValueMap(map: Map<K, V>): Map<K, V?>
inline fun <T : Any> subAssert(noinline assertionCreator: Assert<T>.() -> Unit): Assert<T>.() -> Unit
inline fun <T> subAssertNullable(noinline assertionCreator: AssertionPlantNullable<T>.() -> Unit): AssertionPlantNullable<T>.() -> Unit
inline fun <T> subExpect(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>.() -> Unit
fun <T : Any> ArgumentMapperBuilder<T?>.toNullOr(): ArgumentToNullOrMapperBuilder<T>
inline fun <reified T> toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>
fun validateAtMost(times: Int, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
fun validateButAtMost(atLeastTimes: Int, butAtMostTimes: Int, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
interface VarArgHelper<out T>

abstract val expected: T
open val mapArguments: ArgumentMapperBuilder<T>
abstract val otherExpected: Array<out T>
open fun toList(): List<T>

package ch.tutteli.atrium.domain.creating

val anyAssertions: AnyAssertions
interface AnyAssertions

abstract fun <T, TSub : Any> isA(expect: Expect<T>, subType: KClass<TSub>): ChangedSubjectPostStep<T, TSub>
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
abstract fun <T : Any> isNotNullBut(plant: AssertionPlantNullable<T?>, type: KClass<T>, expected: T): Assertion
abstract fun <T> isNotSame(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T : Any> isNullable(plant: AssertionPlantNullable<T?>, type: KClass<T>, expectedOrNull: T?): Assertion
abstract fun <T : Any> isNullIfNullGivenElse(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreatorOrNull: (AssertionPlant<T>.() -> Unit)?): Assertion
abstract fun <T> isSame(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T> notToBe(subjectProvider: SubjectProvider<T>, expected: T): Assertion
open fun <T : Any> notToBeNull(expect: Expect<T?>, subType: KClass<T>): ChangedSubjectPostStep<T?, T>
abstract fun <T> toBe(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T> toBeNull(subjectProvider: SubjectProvider<T>): Assertion
abstract fun <T : Any> toBeNullIfNullGivenElse(expect: Expect<T?>, type: KClass<T>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion

val bigDecimalAssertions: BigDecimalAssertions
interface BigDecimalAssertions

abstract fun <T : BigDecimal> isEqualIncludingScale(subjectProvider: SubjectProvider<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
abstract fun <T : BigDecimal> isNotEqualIncludingScale(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNotNumericallyEqualTo(subjectProvider: SubjectProvider<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNumericallyEqualTo(subjectProvider: SubjectProvider<T>, expected: T): Assertion

val charSequenceAssertions: CharSequenceAssertions
interface CharSequenceAssertions

abstract fun <T : CharSequence> containsBuilder(subjectProvider: SubjectProvider<T>): CharSequenceContains.Builder<T, NoOpSearchBehaviour>
abstract fun <T : CharSequence> containsNotBuilder(subjectProvider: SubjectProvider<T>): CharSequenceContains.Builder<T, NotSearchBehaviour>
abstract fun endsNotWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
abstract fun endsWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
abstract fun isEmpty(subjectProvider: SubjectProvider<CharSequence>): Assertion
abstract fun isNotBlank(subjectProvider: SubjectProvider<CharSequence>): Assertion
abstract fun isNotEmpty(subjectProvider: SubjectProvider<CharSequence>): Assertion
abstract fun <T : CharSequence> matches(expect: Expect<T>, expected: Regex): Assertion
abstract fun <T : CharSequence> mismatches(expect: Expect<T>, expected: Regex): Assertion
abstract fun startsNotWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion
abstract fun startsWith(subjectProvider: SubjectProvider<CharSequence>, expected: CharSequence): Assertion

val chronoLocalDateAssertions: ChronoLocalDateAssertions
interface ChronoLocalDateAssertions

abstract fun <T : ChronoLocalDate> isAfter(expect: Expect<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEquals(expect: Expect<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBefore(expect: Expect<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEquals(expect: Expect<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isEqual(expect: Expect<T>, expected: ChronoLocalDate): Assertion

val chronoLocalDateTimeAssertions: ChronoLocalDateTimeAssertions
interface ChronoLocalDateTimeAssertions

abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEquals(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEquals(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(expect: Expect<T>, expected: ChronoLocalDateTime<*>): Assertion

val chronoZonedDateTimeAssertions: ChronoZonedDateTimeAssertions
interface ChronoZonedDateTimeAssertions

abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(expect: Expect<T>, expected: ChronoZonedDateTime<*>): Assertion

val collectionAssertions: CollectionAssertions
interface CollectionAssertions

abstract fun hasSize(plant: AssertionPlant<Collection<*>>, size: Int): Assertion
abstract fun isEmpty(subjectProvider: SubjectProvider<Collection<*>>): Assertion
abstract fun isNotEmpty(subjectProvider: SubjectProvider<Collection<*>>): Assertion
abstract fun <T : Collection<*>> size(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun size(plant: AssertionPlant<Collection<*>>, assertionCreator: Assert<Int>.() -> Unit): Assertion

val comparableAssertions: ComparableAssertions
interface ComparableAssertions

abstract fun <T1 : Comparable<T2>, T2> isEqualComparingTo(expect: Expect<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterOrEquals(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThan(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessOrEquals(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThan(subjectProvider: SubjectProvider<T1>, expected: T2): Assertion

val featureAssertions: FeatureAssertions
interface FeatureAssertions

abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlant<R>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>

val floatingPointAssertions: FloatingPointAssertions
expect interface FloatingPointAssertions : FloatingPointAssertionsCommon

abstract fun <T : BigDecimal> toBeWithErrorTolerance(subjectProvider: SubjectProvider<T>, expected: T, tolerance: T): Assertion

interface FloatingPointAssertionsCommon

abstract fun toBeWithErrorTolerance(subjectProvider: SubjectProvider<Float>, expected: Float, tolerance: Float): Assertion
abstract fun toBeWithErrorTolerance(subjectProvider: SubjectProvider<Double>, expected: Double, tolerance: Double): Assertion

val fun0Assertions: Fun0Assertions
interface Fun0Assertions

abstract fun <R, T : () -> R> isNotThrowing(expect: Expect<T>): ChangedSubjectPostStep<*, R>
abstract fun <TExpected : Throwable> isThrowing(expect: Expect<() -> Any?>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<*, TExpected>

val iterableAssertions: IterableAssertions
interface IterableAssertions

abstract fun <E : Any, T : Iterable<E?>> all(expect: Expect<T>, assertionCreator: (Expect<E>.() -> Unit)?): Assertion
abstract fun <E : Any> all(plant: AssertionPlant<Iterable<E?>>, assertionCreator: (AssertionPlant<E>.() -> Unit)?): Assertion
abstract fun <E, T : Iterable<E>> containsBuilder(subjectProvider: SubjectProvider<T>): IterableContains.Builder<E, T, NoOpSearchBehaviour>
abstract fun <E, T : Iterable<E>> containsNotBuilder(subjectProvider: SubjectProvider<T>): IterableContains.Builder<E, T, NotSearchBehaviour>
abstract fun <E, T : Iterable<E>> hasNext(expect: Expect<T>): Assertion
abstract fun <E, T : Iterable<E>> hasNotNext(expect: Expect<T>): Assertion
abstract fun <E : Comparable<E>, T : Iterable<E>> max(expect: Expect<T>): ExtractedFeaturePostStep<T, E>
abstract fun <E : Comparable<E>, T : Iterable<E>> min(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

val iteratorAssertions: IteratorAssertions
interface IteratorAssertions

abstract fun <E, T : Iterator<E>> hasNext(expect: Expect<T>): Assertion
abstract fun <E, T : Iterator<E>> hasNotNext(expect: Expect<T>): Assertion

val listAssertions: ListAssertions
interface ListAssertions

abstract fun <E, T : List<E>> get(expect: Expect<T>, index: Int): ExtractedFeaturePostStep<T, E>
abstract fun <T : Any> get(plant: AssertionPlant<List<T>>, index: Int): AssertionPlant<T>
abstract fun <T : Any> get(plant: AssertionPlant<List<T>>, index: Int, assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
abstract fun <T> getNullable(plant: AssertionPlant<List<T>>, index: Int): AssertionPlantNullable<T>
abstract fun <T> getNullable(plant: AssertionPlant<List<T>>, index: Int, assertionCreator: AssertionPlantNullable<T>.() -> Unit): Assertion

val localDateAssertions: LocalDateAssertions
interface LocalDateAssertions

abstract fun <T : LocalDate> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : LocalDate> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
abstract fun <T : LocalDate> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : LocalDate> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

val localDateTimeAssertions: LocalDateTimeAssertions
interface LocalDateTimeAssertions

abstract fun <T : LocalDateTime> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : LocalDateTime> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
abstract fun <T : LocalDateTime> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : LocalDateTime> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

val mapAssertions: MapAssertions
interface MapAssertions

abstract fun <K, V, T : Map<out K, V>> contains(expect: Expect<T>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V> contains(plant: AssertionPlant<Map<out K, V>>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K> containsKey(subjectProvider: SubjectProvider<Map<out K, *>>, key: K): Assertion
abstract fun <K, V : Any, T : Map<out K, V?>> containsKeyWithValueAssertions(expect: Expect<T>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any> containsKeyWithValueAssertions(plant: AssertionPlant<Map<out K, V?>>, keyValues: List<Pair<K, (Assert<V>.() -> Unit)?>>): Assertion
abstract fun <K> containsNotKey(subjectProvider: SubjectProvider<Map<out K, *>>, key: K): Assertion
abstract fun <K, V, T : Map<out K, V>> getExisting(expect: Expect<T>, key: K): ExtractedFeaturePostStep<T, V>
abstract fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlant<V>
abstract fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
abstract fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlantNullable<V>
abstract fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun hasSize(plant: AssertionPlant<Map<*, *>>, size: Int): Assertion
abstract fun isEmpty(subjectProvider: SubjectProvider<Map<*, *>>): Assertion
abstract fun isNotEmpty(subjectProvider: SubjectProvider<Map<*, *>>): Assertion
abstract fun <K> keys(plant: AssertionPlant<Map<out K, *>>, assertionCreator: AssertionPlant<Set<K>>.() -> Unit): Assertion
abstract fun <T : Map<*, *>> size(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <V> values(plant: AssertionPlant<Map<*, V>>, assertionCreator: AssertionPlant<Collection<V>>.() -> Unit): Assertion

val mapEntryAssertions: MapEntryAssertions
interface MapEntryAssertions

abstract fun <K, V, T : Entry<K, V>> isKeyValue(expect: Expect<T>, key: K, value: V): Assertion
abstract fun <K : Any, V : Any> isKeyValue(plant: AssertionPlant<Entry<K, V>>, key: K, value: V): Assertion
abstract fun <K, T : Entry<K, *>> key(expect: Expect<T>): ExtractedFeaturePostStep<T, K>
abstract fun <K : Any> key(plant: AssertionPlant<Entry<K, *>>, assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
abstract fun <K> nullableKey(plant: AssertionPlant<Entry<K, *>>, assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
abstract fun <V> nullableValue(plant: AssertionPlant<Entry<*, V>>, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun <V, T : Entry<*, V>> value(expect: Expect<T>): ExtractedFeaturePostStep<T, V>
abstract fun <V : Any> value(plant: AssertionPlant<Entry<*, V>>, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion

data class MetaFeature<T>

MetaFeature(description: String, representation: Any?, maybeSubject: Option<T>)
MetaFeature(description: String, subject: T)
MetaFeature(description: Translatable, representation: Any?, maybeSubject: Option<T>)
val description: Translatable
val maybeSubject: Option<T>
val representation: Any?

val newFeatureAssertions: NewFeatureAssertions
interface NewFeatureAssertions

abstract fun <T, R> genericFeature(expect: Expect<T>, metaFeature: MetaFeature<R>): ExtractedFeaturePostStep<T, R>

val optionalAssertions: OptionalAssertions
interface OptionalAssertions

abstract fun <T : Optional<*>> isEmpty(expect: Expect<T>): Assertion
abstract fun <E, T : Optional<E>> isPresent(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

val pairAssertions: PairAssertions
interface PairAssertions

abstract fun <K, T : Pair<K, *>> first(expect: Expect<T>): ExtractedFeaturePostStep<T, K>
abstract fun <K : Any> first(plant: AssertionPlant<Pair<K, *>>, assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
abstract fun <K> nullableFirst(plant: AssertionPlant<Pair<K, *>>, assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
abstract fun <V> nullableSecond(plant: AssertionPlant<Pair<*, V>>, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun <V, T : Pair<*, V>> second(expect: Expect<T>): ExtractedFeaturePostStep<T, V>
abstract fun <V : Any> second(plant: AssertionPlant<Pair<*, V>>, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion

val pathAssertions: PathAssertions
interface PathAssertions

abstract fun <T : Path> endsNotWith(expect: Expect<T>, expected: Path): Assertion
abstract fun <T : Path> endsWith(expect: Expect<T>, expected: Path): Assertion
abstract fun <T : Path> exists(expect: Expect<T>): Assertion
abstract fun <T : Path> existsNot(expect: Expect<T>): Assertion
abstract fun <T : Path> extension(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
abstract fun <T : Path> fileName(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
abstract fun <T : Path> fileNameWithoutExtension(expect: Expect<T>): ExtractedFeaturePostStep<T, String>
abstract fun <T : Path> hasSameBinaryContentAs(expect: Expect<T>, targetPath: Path): Assertion
abstract fun <T : Path> hasSameTextualContentAs(expect: Expect<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
abstract fun <T : Path> isDirectory(expect: Expect<T>): Assertion
abstract fun <T : Path> isReadable(expect: Expect<T>): Assertion
abstract fun <T : Path> isRegularFile(expect: Expect<T>): Assertion
abstract fun <T : Path> isWritable(expect: Expect<T>): Assertion
abstract fun <T : Path> parent(expect: Expect<T>): ExtractedFeaturePostStep<T, Path>
abstract fun <T : Path> resolve(expect: Expect<T>, other: String): ExtractedFeaturePostStep<T, Path>
abstract fun <T : Path> startsNotWith(expect: Expect<T>, expected: Path): Assertion
abstract fun <T : Path> startsWith(expect: Expect<T>, expected: Path): Assertion

val throwableAssertions: ThrowableAssertions
interface ThrowableAssertions

abstract fun <TExpected : Throwable> cause(expect: Expect<out Throwable>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<Throwable?, TExpected>
open fun thrownBuilder(assertionVerb: String, act: () -> Unit, reporter: Reporter): ThrowableThrown.Builder
abstract fun thrownBuilder(assertionVerb: Translatable, act: () -> Unit, reporter: Reporter): ThrowableThrown.Builder

val zonedDateTimeAssertions: ZonedDateTimeAssertions
interface ZonedDateTimeAssertions

abstract fun <T : ZonedDateTime> day(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : ZonedDateTime> dayOfWeek(expect: Expect<T>): ExtractedFeaturePostStep<T, DayOfWeek>
abstract fun <T : ZonedDateTime> month(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>
abstract fun <T : ZonedDateTime> year(expect: Expect<T>): ExtractedFeaturePostStep<T, Int>

package ch.tutteli.atrium.domain.creating.any.typetransformation

interface AnyTypeTransformation

interface Creator<S : Any, T : Any>

abstract fun create(parameterObject: AnyTypeTransformation.ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: AnyTypeTransformation.FailureHandler<S, T>): Unit

interface FailureHandler<in S : Any, out T : Any>

abstract fun createAndAddAssertionToPlant(parameterObject: AnyTypeTransformation.ParameterObject<S, T>): Unit
abstract fun createFailingAssertion(description: Translatable, representation: Any): Assertion

data class ParameterObject<out S : Any, in T : Any>

ParameterObject(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<S?, *>, assertionCreator: AssertionPlant<T>.() -> Unit, warningTransformationFailed: Translatable)
val assertionCreator: AssertionPlant<T>.() -> Unit
val description: Translatable
val representation: Any
val subjectPlant: BaseAssertionPlant<S?, *>
val warningTransformationFailed: Translatable

package ch.tutteli.atrium.domain.creating.any.typetransformation.creators

val anyTypeTransformationAssertions: AnyTypeTransformationAssertions
interface AnyTypeTransformationAssertions

abstract fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: AnyTypeTransformation.FailureHandler<T, TSub>): Unit
abstract fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Unit
abstract fun <S : Any, T : Any> transform(parameterObject: AnyTypeTransformation.ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: AnyTypeTransformation.FailureHandler<S, T>): Unit

package ch.tutteli.atrium.domain.creating.any.typetransformation.failurehandlers

val failureHandlerFactory: FailureHandlerFactory
interface FailureHandlerFactory

abstract fun <S : Any, T : Any> newExplanatory(): AnyTypeTransformation.FailureHandler<S, T>
abstract fun <S : Any, T : Any> newExplanatoryWithHint(showHint: () -> Boolean, failureHintFactory: () -> Assertion): AnyTypeTransformation.FailureHandler<S, T>

package ch.tutteli.atrium.domain.creating.basic.contains

interface Contains

interface Builder<out T : Any, out S : Contains.SearchBehaviour>

abstract val searchBehaviour: S
abstract val subjectProvider: SubjectProvider<T>

interface Checker

abstract fun createAssertion(foundNumberOfTimes: Int): Assertion

interface CheckerOption<out T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.Builder<T, S>>

abstract val checkers: List<C>
abstract val containsBuilder: B

interface Creator<in T : Any, in SC>

abstract fun createAssertionGroup(subjectProvider: SubjectProvider<T>, searchCriteria: List<SC>): AssertionGroup

interface SearchBehaviour

abstract fun decorateDescription(description: Translatable): Translatable

package ch.tutteli.atrium.domain.creating.changers

class ChangedSubjectPostStep<T, R> : PostFinalStep<T, R, Expect<R>>

ChangedSubjectPostStep(expect: Expect<T>, transform: Expect<T>.() -> Expect<R>, transformAndApply: Expect<T>.(Expect<R>.() -> Unit) -> Expect<R>)

class ExtractedFeaturePostStep<T, R> : PostFinalStep<T, R, FeatureExpect<T, R>>

ExtractedFeaturePostStep(expect: Expect<T>, extract: Expect<T>.() -> FeatureExpect<T, R>, extractAndApply: Expect<T>.(Expect<R>.() -> Unit) -> Expect<R>)

class FailureHandlerAdapter<T, R1, R> : SubjectChanger.FailureHandler<T, R>

FailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1)
fun createAssertion(originalAssertionContainer: Expect<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion
val failureHandler: SubjectChanger.FailureHandler<R1, R>
val map: (T) -> R1

val featureExtractor: FeatureExtractor
interface FeatureExtractor

abstract fun <T, R> extract(originalAssertionContainer: Expect<T>, description: Translatable, representationForFailure: Any, featureExtraction: (T) -> Option<R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>, representationInsteadOfFeature: ((R) -> Any)? = null): FeatureExpect<T, R>

abstract class PostFinalStep<T, R, E : Expect<R>>

PostFinalStep(expect: Expect<T>, action: Expect<T>.() -> E, actionAndApply: Expect<T>.(Expect<R>.() -> Unit) -> Expect<R>)
protected val action: Expect<T>.() -> E
protected val actionAndApply: Expect<T>.(Expect<R>.() -> Unit) -> Expect<R>
fun addToFeature(assertionCreator: Expect<R>.() -> Unit): Expect<R>
fun addToInitial(assertionCreator: Expect<R>.() -> Unit): Expect<T>
fun collect(assertionCreator: Expect<R>.() -> Unit): Assertion
protected val expect: Expect<T>
fun getExpectOfFeature(): E

val subjectChanger: SubjectChanger
interface SubjectChanger

interface FailureHandler<T, R>

abstract fun createAssertion(originalAssertionContainer: Expect<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion

abstract fun <T, R> reported(originalAssertionContainer: Expect<T>, description: Translatable, representation: Any, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>): Expect<R>
abstract fun <T, R> unreported(originalAssertionContainer: Expect<T>, transformation: (T) -> R): Expect<R>
abstract fun <T, R> unreportedNullableToAssert(originalPlant: SubjectProvider<T>, transformation: (T) -> R): AssertionPlantNullable<R>
abstract fun <T, R : Any> unreportedToAssert(originalPlant: SubjectProvider<T>, transformation: (T) -> R): Assert<R>

package ch.tutteli.atrium.domain.creating.charsequence.contains

interface CharSequenceContains

interface Builder<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.Builder<T, S>
interface Checker : Contains.Checker
interface CheckerOption<out T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerOption<T, S, CharSequenceContains.Checker, CharSequenceContains.Builder<T, S>>
interface Creator<in T : CharSequence, in SC> : Contains.Creator<T, SC>
interface SearchBehaviour : Contains.SearchBehaviour
interface Searcher<S : CharSequenceContains.SearchBehaviour, SC>

abstract fun search(searchIn: CharSequence, searchFor: SC): Int

package ch.tutteli.atrium.domain.creating.charsequence.contains.checkers

val checkerFactory: CheckerFactory
interface CheckerFactory

abstract fun newAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): CharSequenceContains.Checker
abstract fun newAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): CharSequenceContains.Checker
abstract fun newExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): CharSequenceContains.Checker
abstract fun newNotChecker(): CharSequenceContains.Checker

package ch.tutteli.atrium.domain.creating.charsequence.contains.creators

val charSequenceContainsAssertions: CharSequenceContainsAssertions
interface CharSequenceContainsAssertions

abstract fun <T : CharSequence> defaultTranslationOf(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> regex(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<Regex>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerOption: CharSequenceContains.CheckerOption<T, NoOpSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerOption: CharSequenceContains.CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup

package ch.tutteli.atrium.domain.creating.charsequence.contains.searchbehaviours

interface IgnoringCaseSearchBehaviour : CharSequenceContains.SearchBehaviour
interface NoOpSearchBehaviour : CharSequenceContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NotSearchBehaviour : NoOpSearchBehaviour
val searchBehaviourFactory: SearchBehaviourFactory
interface SearchBehaviourFactory

abstract fun <T : CharSequence> ignoringCase(containsBuilder: CharSequenceContains.Builder<T, NoOpSearchBehaviour>): CharSequenceContains.Builder<T, IgnoringCaseSearchBehaviour>

package ch.tutteli.atrium.domain.creating.collectors

val assertionCollector: AssertionCollector
interface AssertionCollector

open fun <T> collect(expect: Expect<T>, assertionCreator: Expect<T>.() -> Unit): Assertion
abstract fun <T> collect(maybeSubject: Option<T>, assertionCreator: Expect<T>.() -> Unit): Assertion
open fun <T : Any> collect(plant: AssertionPlant<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
open fun <T : Any> collect(subjectProvider: () -> T, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(subjectProvider: () -> T, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): AssertionGroup
abstract fun <T> collectForComposition(maybeSubject: Option<T>, assertionCreator: Expect<T>.() -> Unit): List<Assertion>
open fun <T> collectNullable(plant: AssertionPlantNullable<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullable(subjectProvider: () -> T, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullableOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, plant: AssertionPlantNullable<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullableOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T : Any> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, plant: AssertionPlant<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
open fun <T : Any> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): AssertionGroup

interface AssertionCollectorForExplanation

open fun <T : Any> collect(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, assertionCreator: (CollectingAssertionPlant<T>.() -> Unit)?): List<Assertion>
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, collectingPlantFactory: (() -> T) -> C, assertionCreator: (C.() -> Unit)?): List<Assertion>
open fun <T> collectNullable(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, assertionCreator: (CollectingAssertionPlantNullable<T>.() -> Unit)?): List<Assertion>

val nonThrowingAssertionCollectorForExplanation: NonThrowingAssertionCollectorForExplanation
interface NonThrowingAssertionCollectorForExplanation : AssertionCollectorForExplanation
val throwingAssertionCollectorForExplanation: ThrowingAssertionCollectorForExplanation
interface ThrowingAssertionCollectorForExplanation : AssertionCollectorForExplanation

package ch.tutteli.atrium.domain.creating.feature.extract

interface FeatureExtractor

val builder: FeatureExtractor.DescriptionOption
interface Creator<TSubject, T : Any> : FeatureExtractor.CreatorLike<TSubject, T, AssertionPlant<T>, CollectingAssertionPlant<T>>
interface CreatorLike<TSubject, T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>>

abstract fun extract(): A
abstract fun extractAndAssertIt(assertionCreator: C.() -> Unit): Assertion
abstract val featureRepresentation: Translatable
abstract val parameterObject: FeatureExtractor.ParameterObject<TSubject, T>

interface CreatorNullable<TSubject, T> : FeatureExtractor.CreatorLike<TSubject, T, AssertionPlantNullable<T>, CollectingAssertionPlantNullable<T>>
interface DescriptionOption

open fun feature(featureRepresentation: () -> String): FeatureExtractor.ParameterObjectOption
open fun methodCall(methodName: String, vararg arguments: Any?): FeatureExtractor.ParameterObjectOption
abstract fun withDescription(translatable: Translatable): FeatureExtractor.ParameterObjectOption

data class ParameterObject<TSubject, T>

ParameterObject(subjectPlant: BaseAssertionPlant<TSubject, *>, extractionNotSuccessful: Translatable, warningCannotEvaluate: Translatable, canBeExtracted: (TSubject) -> Boolean, featureExtraction: (TSubject) -> T)
val canBeExtracted: (TSubject) -> Boolean
val extractionNotSuccessful: Translatable
val featureExtraction: (TSubject) -> T
val subjectPlant: BaseAssertionPlant<TSubject, *>
val warningCannotEvaluate: Translatable

interface ParameterObjectOption

abstract val featureDescription: Translatable
open fun <TSubject : Any, T : Any> withParameterObject(parameterObject: FeatureExtractor.ParameterObject<TSubject, T>): FeatureExtractor.Creator<TSubject, T>
open fun <TSubject : Any, T> withParameterObjectNullable(parameterObject: FeatureExtractor.ParameterObject<TSubject, T>): FeatureExtractor.CreatorNullable<TSubject, T>

package ch.tutteli.atrium.domain.creating.feature.extract.creators

val featureExtractorCreatorFactory: FeatureExtractorCreatorFactory
interface FeatureExtractorCreatorFactory

abstract fun <TSubject : Any, T : Any> create(featureRepresentation: Translatable, parameterObject: FeatureExtractor.ParameterObject<TSubject, T>): FeatureExtractor.Creator<TSubject, T>
abstract fun <TSubject : Any, T> createNullable(featureRepresentation: Translatable, parameterObject: FeatureExtractor.ParameterObject<TSubject, T>): FeatureExtractor.CreatorNullable<TSubject, T>

package ch.tutteli.atrium.domain.creating.iterable.contains

interface IterableContains

interface Builder<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : Contains.Builder<T, S>
interface Checker : Contains.Checker
interface CheckerOption<out E, out T : Iterable<E>, out S : IterableContains.SearchBehaviour> : Contains.CheckerOption<T, S, IterableContains.Checker, IterableContains.Builder<E, T, S>>
interface Creator<in T : Iterable<*>, in SC> : Contains.Creator<T, SC>
interface SearchBehaviour : Contains.SearchBehaviour

package ch.tutteli.atrium.domain.creating.iterable.contains.checkers

val checkerFactory: CheckerFactory
interface CheckerFactory

abstract fun newAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): IterableContains.Checker
abstract fun newAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): IterableContains.Checker
abstract fun newExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): IterableContains.Checker
abstract fun newNotChecker(): IterableContains.Checker

package ch.tutteli.atrium.domain.creating.iterable.contains.creators

val iterableContainsAssertions: IterableContainsAssertions
interface IterableContainsAssertions

abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnlyWithAssert(builder: IterableContains.Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderWithAssert(checkerOption: IterableContains.CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGroupedWithAssert(builder: IterableContains.Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(AssertionPlant<E>.() -> Unit)?>>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyWithAssert(builder: IterableContains.Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(AssertionPlant<E>.() -> Unit)?>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: IterableContains.CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnly(builder: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

package ch.tutteli.atrium.domain.creating.iterable.contains.searchbehaviours

interface InAnyOrderOnlySearchBehaviour : IterableContains.SearchBehaviour
interface InAnyOrderSearchBehaviour : IterableContains.SearchBehaviour
interface InOrderOnlyGroupedSearchBehaviour : IterableContains.SearchBehaviour
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
interface InOrderOnlySearchBehaviour : IterableContains.SearchBehaviour
interface InOrderSearchBehaviour : IterableContains.SearchBehaviour
interface NoOpSearchBehaviour : IterableContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NotSearchBehaviour : InAnyOrderSearchBehaviour
val searchBehaviourFactory: SearchBehaviourFactory
interface SearchBehaviourFactory

abstract fun <E, T : Iterable<E>> inAnyOrder(builder: IterableContains.Builder<E, T, NoOpSearchBehaviour>): IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContains.Builder<E, T, InAnyOrderSearchBehaviour>): IterableContains.Builder<E, T, InAnyOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrder(builder: IterableContains.Builder<E, T, NoOpSearchBehaviour>): IterableContains.Builder<E, T, InOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContains.Builder<E, T, InOrderSearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: IterableContains.Builder<E, T, InOrderOnlySearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: IterableContains.Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): IterableContains.Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>

package ch.tutteli.atrium.domain.creating.throwable.thrown

interface ThrowableThrown

interface AbsentThrowableMessageProvider

abstract val message: RawString

interface Builder

abstract val act: () -> Unit
abstract val assertionVerb: Translatable
abstract val reporter: Reporter

interface Creator<TExpected : Throwable>

abstract fun executeActAndCreateAssertion(throwableThrownBuilder: ThrowableThrown.Builder, description: Translatable, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit
abstract fun executeActAssertNothingThrown(throwableThrownBuilder: ThrowableThrown.Builder): Unit

package ch.tutteli.atrium.domain.creating.throwable.thrown.creators

val throwableThrownAssertions: ThrowableThrownAssertions
interface ThrowableThrownAssertions

abstract fun nothingThrown(throwableThrownBuilder: ThrowableThrown.Builder): Unit
abstract fun <TExpected : Throwable> toBe(throwableThrownBuilder: ThrowableThrown.Builder, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit

package ch.tutteli.atrium.domain.creating.throwable.thrown.providers

val absentThrowableMessageProviderFactory: AbsentThrowableMessageProviderFactory
interface AbsentThrowableMessageProviderFactory

abstract fun translatableBased(translatable: Translatable): ThrowableThrown.AbsentThrowableMessageProvider

package ch.tutteli.atrium.domain.creating.typeutils

typealias CharSequenceOrNumberOrChar = Any
typealias IterableLike = Any

package ch.tutteli.atrium.domain.kotlin_1_3.creating

val resultAssertions: ResultAssertions
interface ResultAssertions

abstract fun <TExpected : Throwable> isFailure(expect: Expect<out Result<*>>, expectedType: KClass<TExpected>): ChangedSubjectPostStep<Throwable?, TExpected>
abstract fun <E, T : Result<E>> isSuccess(expect: Expect<T>): ExtractedFeaturePostStep<T, E>

package ch.tutteli.atrium.logic

inline val <T> Expect<T>._logic: AssertionContainer<T>
inline val <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStep<T, S>._logic: CharSequenceContains.EntryPointStepLogic<T, S>
inline val <T : CharSequence, S : CharSequenceContains.SearchBehaviour> WithTimesCheckerStep<T, S>._logic: WithTimesCheckerStepLogic<T, S>
inline val <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.CheckerStep<T, S>._logic: CharSequenceContains.CheckerStepLogic<T, S>
inline val <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>._logic: IterableLikeContains.EntryPointStepLogic<E, T, S>
inline val <E, T : Any, S : IterableLikeContains.SearchBehaviour> WithTimesCheckerStep<E, T, S>._logic: WithTimesCheckerStepLogic<E, T, S>
inline val <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.CheckerStep<E, T, S>._logic: IterableLikeContains.CheckerStepLogic<E, T, S>
inline val <K, V, T : Any, S : MapLikeContains.SearchBehaviour> MapLikeContains.EntryPointStep<K, V, T, S>._logic: MapLikeContains.EntryPointStepLogic<K, V, T, S>
inline fun <T> Expect<T>._logicAppend(factory: AssertionContainer<T>.() -> Assertion): Expect<T>
inline fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.CheckerStep<T, S>._logicAppend(factory: CharSequenceContains.CheckerStepLogic<T, S>.() -> Assertion): Expect<T>
inline fun <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStep<E, T, S>._logicAppend(factory: IterableLikeContains.EntryPointStepLogic<E, T, S>.() -> Assertion): Expect<T>
inline fun <E, T : Any, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.CheckerStep<E, T, S>._logicAppend(factory: IterableLikeContains.CheckerStepLogic<E, T, S>.() -> Assertion): Expect<T>
inline fun <K, V, T : Any, S : MapLikeContains.SearchBehaviour> MapLikeContains.EntryPointStep<K, V, T, S>._logicAppend(factory: MapLikeContains.EntryPointStepLogic<K, V, T, S>.() -> Assertion): Expect<T>
interface AnyAssertions

abstract fun <T> because(container: AssertionContainer<T>, reason: String, assertionCreator: Expect<T>.() -> Unit): Assertion
abstract fun <T, TSub : Any> isA(container: AssertionContainer<T>, subType: KClass<TSub>): SubjectChangerBuilder.ExecutionStep<T, TSub>
abstract fun <T> isNotIn(container: AssertionContainer<T>, expected: Iterable<T>): Assertion
abstract fun <T> isNotSameAs(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> isSameAs(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> notToBe(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : Any> notToBeNullButOfType(container: AssertionContainer<T?>, subType: KClass<T>): SubjectChangerBuilder.ExecutionStep<T?, T>
abstract fun <T> toBe(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T> toBeNull(container: AssertionContainer<T>): Assertion
abstract fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, type: KClass<T>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
abstract fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion

interface BigDecimalAssertions

abstract fun <T : BigDecimal> isEqualIncludingScale(container: AssertionContainer<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
abstract fun <T : BigDecimal> isNotEqualIncludingScale(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNotNumericallyEqualTo(container: AssertionContainer<T>, expected: T): Assertion
abstract fun <T : BigDecimal> isNumericallyEqualTo(container: AssertionContainer<T>, expected: T): Assertion

val <T> AssertionContainer<T>.changeSubject: SubjectChangerBuilder.KindStep<T>
interface CharSequenceAssertions

abstract fun <T : CharSequence> containsBuilder(container: AssertionContainer<T>): CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
abstract fun <T : CharSequence> containsNotBuilder(container: AssertionContainer<T>): NotCheckerStep<T, NotSearchBehaviour>
abstract fun <T : CharSequence> endsNotWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> endsWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> isEmpty(container: AssertionContainer<T>): Assertion
abstract fun <T : CharSequence> isNotBlank(container: AssertionContainer<T>): Assertion
abstract fun <T : CharSequence> isNotEmpty(container: AssertionContainer<T>): Assertion
abstract fun <T : CharSequence> matches(container: AssertionContainer<T>, expected: Regex): Assertion
abstract fun <T : CharSequence> mismatches(container: AssertionContainer<T>, expected: Regex): Assertion
abstract fun <T : CharSequence> startsNotWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
abstract fun <T : CharSequence> startsWith(container: AssertionContainer<T>, expected: CharSequence): Assertion

interface ChronoLocalDateAssertions

abstract fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
abstract fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: String): Assertion

interface ChronoLocalDateTimeAssertions

abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
abstract fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion

interface ChronoZonedDateTimeAssertions

abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
abstract fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion

inline fun <T> AssertionContainer<T>.collect(noinline assertionCreator: Expect<T>.() -> Unit): Assertion
fun <T, R> TransformationExecutionStep<T, R, *>.collectAndLogicAppend(assertionCreator: AssertionContainer<R>.() -> Assertion): Expect<T>
inline fun <T> collectForComposition(maybeSubject: Option<T>, noinline assertionCreator: Expect<T>.() -> Unit): List<Assertion>
interface CollectionLikeAssertions

abstract fun <T> isEmpty(container: AssertionContainer<T>, converter: (T) -> Collection<*>): Assertion
abstract fun <T> isNotEmpty(container: AssertionContainer<T>, converter: (T) -> Collection<*>): Assertion
abstract fun <T> size(container: AssertionContainer<T>, converter: (T) -> Collection<*>): FeatureExtractorBuilder.ExecutionStep<T, Int>

interface ComparableAssertions

abstract fun <T1 : Comparable<T2>, T2> isEqualComparingTo(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isGreaterThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
abstract fun <T1 : Comparable<T2>, T2> isLessThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion

fun <T> AssertionContainer<T>.createDescriptiveAssertion(description: Translatable, representation: Any?, test: (T) -> Boolean): Assertion
val <T> AssertionContainer<T>.extractFeature: FeatureExtractorBuilder.DescriptionStep<T>
interface FeatureAssertions

abstract fun <T, R> f0(container: AssertionContainer<T>, f: KFunction1<T, R>): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, R> f1(container: AssertionContainer<T>, f: KFunction2<T, A1, R>, a1: A1): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, R> f2(container: AssertionContainer<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, R> f3(container: AssertionContainer<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, A4, R> f4(container: AssertionContainer<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, A1, A2, A3, A4, A5, R> f5(container: AssertionContainer<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, R> manualFeature(container: AssertionContainer<T>, description: Translatable, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract fun <T, TProperty> property(container: AssertionContainer<T>, property: KProperty1<in T, TProperty>): FeatureExtractorBuilder.ExecutionStep<T, TProperty>

interface FloatingPointAssertions

abstract fun toBeWithErrorTolerance(container: AssertionContainer<Float>, expected: Float, tolerance: Float): Assertion
abstract fun toBeWithErrorTolerance(container: AssertionContainer<Double>, expected: Double, tolerance: Double): Assertion

interface FloatingPointJvmAssertions

abstract fun <T : BigDecimal> toBeWithErrorTolerance(container: AssertionContainer<T>, expected: BigDecimal, tolerance: BigDecimal): Assertion

interface Fun0Assertions

abstract fun <R, T : () -> R> notToThrow(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<*, R>
abstract fun <TExpected : Throwable> toThrow(container: AssertionContainer<() -> Any?>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<*, TExpected>

fun <T, R> AssertionContainer<T>.genericSubjectBasedFeature(provider: (T) -> MetaFeature<R>): FeatureExtractorBuilder.ExecutionStep<T, R>
interface IterableLikeAssertions

abstract fun <T, E> all(container: AssertionContainer<T>, converter: (T) -> Iterable<E?>, assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Assertion
abstract fun <T, E> builderContainsInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>
abstract fun <T, E> builderContainsNotInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): NotCheckerStep<E, T, NotSearchBehaviour>
abstract fun <T, E> containsNoDuplicates(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E> hasNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E> hasNotNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
abstract fun <T, E : Comparable<E>> max(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
abstract fun <T, E : Comparable<E>> min(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>

interface IteratorAssertions

abstract fun <E, T : Iterator<E>> hasNext(container: AssertionContainer<T>): Assertion
abstract fun <E, T : Iterator<E>> hasNotNext(container: AssertionContainer<T>): Assertion

interface ListAssertions

abstract fun <E, T : List<E>> get(container: AssertionContainer<T>, index: Int): FeatureExtractorBuilder.ExecutionStep<T, E>

interface LocalDateAssertions

abstract fun day(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>
abstract fun dayOfWeek(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, DayOfWeek>
abstract fun month(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>
abstract fun year(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>

interface LocalDateTimeAssertions

abstract fun day(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>
abstract fun dayOfWeek(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, DayOfWeek>
abstract fun month(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>
abstract fun year(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>

fun <T, R> AssertionContainer<T>.manualFeature(description: String, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
interface MapEntryAssertions

abstract fun <K, V, T : Entry<K, V>> isKeyValue(container: AssertionContainer<T>, key: K, value: V): Assertion
abstract fun <K, T : Entry<K, *>> key(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
abstract fun <V, T : Entry<*, V>> value(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>

interface MapLikeAssertions

abstract fun <T, K, V> builderContainsInMapLike(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>): MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>
abstract fun <K, T> containsKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
abstract fun <K, T> containsNotKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
abstract fun <K, V, T> getExisting(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, key: K): FeatureExtractorBuilder.ExecutionStep<T, V>

interface OptionalAssertions

abstract fun <T : Optional<*>> isEmpty(container: AssertionContainer<T>): Assertion
abstract fun <E, T : Optional<E>> isPresent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, E>

interface PairAssertions

abstract fun <K, T : Pair<K, *>> first(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
abstract fun <V, T : Pair<*, V>> second(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>

interface PathAssertions

abstract fun <T : Path> endsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> endsWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> exists(container: AssertionContainer<T>, linkOption: LinkOption? = null): Assertion
abstract fun <T : Path> existsNot(container: AssertionContainer<T>, linkOption: LinkOption? = null): Assertion
abstract fun <T : Path> extension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> fileName(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> fileNameWithoutExtension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
abstract fun <T : Path> hasDirectoryEntry(container: AssertionContainer<T>, entries: List<String>): Assertion
abstract fun <T : Path> hasSameBinaryContentAs(container: AssertionContainer<T>, targetPath: Path): Assertion
abstract fun <T : Path> hasSameTextualContentAs(container: AssertionContainer<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
abstract fun <T : Path> isAbsolute(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isDirectory(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isExecutable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isReadable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isRegularFile(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isRelative(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> isWritable(container: AssertionContainer<T>): Assertion
abstract fun <T : Path> parent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, Path>
abstract fun <T : Path> resolve(container: AssertionContainer<T>, other: String): FeatureExtractorBuilder.ExecutionStep<T, Path>
abstract fun <T : Path> startsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
abstract fun <T : Path> startsWith(container: AssertionContainer<T>, expected: Path): Assertion

interface ThrowableAssertions

abstract fun <TExpected : Throwable> causeIsA(container: AssertionContainer<out Throwable>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected>

fun <T> Expect<T>.toAssertionContainer(): AssertionContainer<T>
fun <T> AssertionContainer<T>.toExpect(): Expect<T>
interface ZonedDateTimeAssertions

abstract fun day(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>
abstract fun dayOfWeek(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, DayOfWeek>
abstract fun month(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>
abstract fun year(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>

package ch.tutteli.atrium.logic.assertions.impl

class LazyThreadUnsafeAssertionGroup : AssertionGroup

LazyThreadUnsafeAssertionGroup(assertionCreator: () -> AssertionGroup)
val assertions: List<Assertion>
val description: Translatable
fun holds(): Boolean
val representation: Any
val type: AssertionGroupType

package ch.tutteli.atrium.logic.creating.basic.contains

interface Contains

interface Checker

abstract fun createAssertion(foundNumberOfTimes: Int): Assertion

interface CheckerStep<T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.EntryPointStep<T, S>>
interface CheckerStepLogic<T : Any, out S : Contains.SearchBehaviour, out C : Contains.Checker, out B : Contains.EntryPointStepLogic<T, S>>

abstract val checkers: List<C>
abstract val entryPointStepLogic: B

interface Creator<T, in SC>

abstract fun createAssertionGroup(container: AssertionContainer<T>, searchCriteria: List<SC>): AssertionGroup

interface EntryPointStep<T : Any, out S : Contains.SearchBehaviour>
interface EntryPointStepLogic<T : Any, out S : Contains.SearchBehaviour>

abstract val container: AssertionContainer<T>
abstract val searchBehaviour: S

interface SearchBehaviour

abstract fun decorateDescription(description: Translatable): Translatable

package ch.tutteli.atrium.logic.creating.basic.contains.checkers

interface AtLeastChecker : WithTimesChecker

abstract val atLeastCall: (Int) -> String
abstract val nameContainsNotFun: String

interface AtMostChecker : WithTimesChecker

abstract val atMostCall: (Int) -> String
abstract val nameContainsNotFun: String

interface ExactlyChecker : WithTimesChecker

abstract val exactlyCall: (Int) -> String
abstract val nameContainsNotFun: String

interface NotChecker : CharSequenceContains.Checker
fun validateAtMost(times: Int, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
fun validateButAtMost(atLeastTimes: Int, butAtMostTimes: Int, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
interface WithTimesChecker : Contains.Checker

abstract val times: Int

package ch.tutteli.atrium.logic.creating.basic.contains.checkers.impl

abstract class ContainsChecker : Contains.Checker

ContainsChecker(times: Int, correctCall: String, wrongCall: (Int) -> String)
protected fun createDescriptiveAssertion(description: Translatable, check: () -> Boolean): DescriptiveAssertion
val times: Int

package ch.tutteli.atrium.logic.creating.basic.contains.creators.impl

abstract class ContainsAssertionCreator<T : Any, TT : Any, in SC, C : Contains.Checker> : Contains.Creator<T, SC>

ContainsAssertionCreator(searchBehaviour: Contains.SearchBehaviour, checkers: List<C>)
fun createAssertionGroup(container: AssertionContainer<T>, searchCriteria: List<SC>): AssertionGroup
protected abstract val descriptionContains: Translatable
protected abstract fun makeSubjectMultipleTimesConsumable(container: AssertionContainer<T>): AssertionContainer<TT>
protected abstract fun searchAndCreateAssertion(multiConsumableContainer: AssertionContainer<TT>, searchCriterion: SC, featureFactory: (numberOfOccurrences: Int, description: Translatable) -> AssertionGroup): AssertionGroup
protected val searchBehaviour: Contains.SearchBehaviour

abstract class ContainsObjectsAssertionCreator<T : Any, TT : Any, in SC, S : Contains.SearchBehaviour, C : Contains.Checker> : ContainsAssertionCreator<T, TT, SC, C>

ContainsObjectsAssertionCreator(searchBehaviour: S, checkers: List<C>)
abstract fun decorateAssertion(container: AssertionContainer<TT>, featureAssertion: Assertion): List<Assertion>
protected abstract val descriptionNumberOfOccurrences: Translatable
protected abstract fun getAssertionGroupType(): AssertionGroupType
protected abstract val groupDescription: Translatable
protected abstract fun search(multiConsumableContainer: AssertionContainer<TT>, searchCriterion: SC): Int
protected fun searchAndCreateAssertion(multiConsumableContainer: AssertionContainer<TT>, searchCriterion: SC, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

package ch.tutteli.atrium.logic.creating.charsequence.contains

interface CharSequenceContains

interface Checker : Contains.Checker
interface CheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerStep<T, S, CharSequenceContains.Checker, CharSequenceContains.EntryPointStep<T, S>>
interface CheckerStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>, CharSequenceContains.CheckerStepLogic<T, S>
interface CheckerStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.CheckerStepLogic<T, S, CharSequenceContains.Checker, CharSequenceContains.EntryPointStepLogic<T, S>>
interface Creator<T : CharSequence, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.EntryPointStep<T, S>, CharSequenceContains.EntryPointStepLogic<T, S>
interface EntryPointStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>
interface SearchBehaviour : Contains.SearchBehaviour
interface Searcher<S : CharSequenceContains.SearchBehaviour, SC>

abstract fun search(searchIn: CharSequence, searchFor: SC): Int

package ch.tutteli.atrium.logic.creating.charsequence.contains.checkers

interface AtLeastChecker : AtLeastChecker, CharSequenceContains.Checker
interface AtMostChecker : AtMostChecker, CharSequenceContains.Checker
interface ExactlyChecker : ExactlyChecker, CharSequenceContains.Checker
interface NotChecker : NotChecker, CharSequenceContains.Checker

package ch.tutteli.atrium.logic.creating.charsequence.contains.checkers.impl

class DefaultAtLeastChecker : AtLeastChecker, ContainsChecker

DefaultAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
val atLeastCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultAtMostChecker : AtMostChecker, ContainsChecker

DefaultAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
val atMostCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultExactlyChecker : ExactlyChecker, ContainsChecker

DefaultExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion
val exactlyCall: (Int) -> String
val nameContainsNotFun: String

class DefaultNotChecker : NotChecker

DefaultNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

package ch.tutteli.atrium.logic.creating.charsequence.contains.creators

interface CharSequenceContainsAssertions

abstract fun <T : CharSequence> regex(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, NoOpSearchBehaviour>, expected: List<Regex>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, NoOpSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, IgnoringCaseSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup

fun <T : CharSequence> CharSequenceContains.CheckerStepLogic<T, NoOpSearchBehaviour>.regex(expected: List<String>): AssertionGroup

package ch.tutteli.atrium.logic.creating.charsequence.contains.creators.impl

class CharSequenceContainsAssertionCreator<T : CharSequence, in SC : Any, S : CharSequenceContains.SearchBehaviour> : ContainsObjectsAssertionCreator<T, String, SC, S, CharSequenceContains.Checker>, CharSequenceContains.Creator<T, SC>

CharSequenceContainsAssertionCreator(searchBehaviour: S, searcher: CharSequenceContains.Searcher<S, SC>, checkers: List<CharSequenceContains.Checker>, groupDescription: Translatable)
fun decorateAssertion(container: AssertionContainer<String>, featureAssertion: Assertion): List<Assertion>
protected val descriptionContains: Translatable
protected val descriptionNumberOfOccurrences: Translatable
protected fun getAssertionGroupType(): AssertionGroupType
protected val groupDescription: Translatable
protected fun makeSubjectMultipleTimesConsumable(container: AssertionContainer<T>): AssertionContainer<String>
protected fun search(multiConsumableContainer: AssertionContainer<String>, searchCriterion: SC): Int

class DefaultCharSequenceContainsAssertions : CharSequenceContainsAssertions

DefaultCharSequenceContainsAssertions()
fun <T : CharSequence> regex(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, NoOpSearchBehaviour>, expected: List<Regex>): AssertionGroup
fun <T : CharSequence> regexIgnoringCase(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
fun <T : CharSequence> values(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, NoOpSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup
fun <T : CharSequence> valuesIgnoringCase(checkerStepLogic: CharSequenceContains.CheckerStepLogic<T, IgnoringCaseSearchBehaviour>, expected: List<CharSequenceOrNumberOrChar>): AssertionGroup

package ch.tutteli.atrium.logic.creating.charsequence.contains.searchbehaviours

interface IgnoringCaseSearchBehaviour : CharSequenceContains.SearchBehaviour
interface NoOpSearchBehaviour : CharSequenceContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NotSearchBehaviour : NoOpSearchBehaviour

package ch.tutteli.atrium.logic.creating.charsequence.contains.searchbehaviours.impl

class IgnoringCaseSearchBehaviourImpl : IgnoringCaseSearchBehaviour

IgnoringCaseSearchBehaviourImpl(previousBehaviour: NoOpSearchBehaviour)
fun decorateDescription(description: Translatable): Translatable

class NoOpSearchBehaviourImpl : NoOpSearchBehaviour

NoOpSearchBehaviourImpl()

class NotSearchBehaviourImpl : NotSearchBehaviour

NotSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

package ch.tutteli.atrium.logic.creating.charsequence.contains.searchers.impl

class IgnoringCaseIndexSearcher : CharSequenceContains.Searcher<IgnoringCaseSearchBehaviour, Any>

IgnoringCaseIndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class IgnoringCaseRegexSearcher : CharSequenceContains.Searcher<IgnoringCaseSearchBehaviour, String>

IgnoringCaseRegexSearcher()
fun search(searchIn: CharSequence, searchFor: String): Int

class IndexSearcher : CharSequenceContains.Searcher<NoOpSearchBehaviour, Any>

IndexSearcher()
fun search(searchIn: CharSequence, searchFor: Any): Int

class RegexSearcher : CharSequenceContains.Searcher<NoOpSearchBehaviour, Regex>

RegexSearcher()
fun search(searchIn: CharSequence, searchFor: Regex): Int

package ch.tutteli.atrium.logic.creating.charsequence.contains.steps

interface AtLeastCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.atLeastCheckerStep(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): AtLeastCheckerStep<T, S>
interface AtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.atMostCheckerStep(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): AtMostCheckerStep<T, S>
interface ButAtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> WithTimesCheckerStepLogic<T, S>.butAtMostCheckerStep(times: Int, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String, atMostCall: (Int) -> String): ButAtMostCheckerStep<T, S>
interface ExactlyCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.exactlyCheckerStep(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): ExactlyCheckerStep<T, S>
val <T : CharSequence, S : NoOpSearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.ignoringCase: CharSequenceContains.EntryPointStep<T, IgnoringCaseSearchBehaviour>
interface NotCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.notCheckerStep(): NotCheckerStep<T, S>
interface NotOrAtMostCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
fun <T : CharSequence, S : CharSequenceContains.SearchBehaviour> CharSequenceContains.EntryPointStepLogic<T, S>.notOrAtMostCheckerStep(times: Int, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String): NotOrAtMostCheckerStep<T, S>
interface WithTimesCheckerStep<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStep<T, S>
interface WithTimesCheckerStepInternal<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : WithTimesCheckerStep<T, S>, WithTimesCheckerStepLogic<T, S>, CharSequenceContains.CheckerStepInternal<T, S>
interface WithTimesCheckerStepLogic<T : CharSequence, out S : CharSequenceContains.SearchBehaviour> : CharSequenceContains.CheckerStepLogic<T, S>

abstract val times: Int

package ch.tutteli.atrium.logic.creating.filesystem

class Failure : IoResult<Nothing>

Failure(path: Path, exception: IOException)
val exception: IOException

sealed class IoResult<out T>

val path: Path

java.nio.file.Path

inline fun <T> Path.runCatchingIo(block: Path.() -> T): IoResult<T>

class Success<out T> : IoResult<T>

Success(path: Path, value: T)
val value: T

package ch.tutteli.atrium.logic.creating.filesystem.hints

fun explainForResolvedLink(path: Path, resolvedPathAssertionProvider: (realPath: Path) -> Assertion): Assertion
fun findHintForProblemWithParent(path: Path): Assertion?
fun hintForAccessDenied(path: Path): Assertion
fun hintForClosestExistingParent(path: Path): Assertion
fun <T : Path> hintForExistsButMissingPermission(subject: T, permissionName: Translatable): Assertion
fun hintForIoException(path: Path, exception: IOException): Assertion
fun hintForOwnersAndPermissions(path: Path): MutableList<Assertion>
fun Descriptive.DescriptionOption<Descriptive.FinalStep>.withFileAttributesFailureHint(expect: Expect<IoResult<BasicFileAttributes>>): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
inline fun <T> Descriptive.DescriptionOption<Descriptive.FinalStep>.withIOExceptionFailureHint(expect: Expect<IoResult<T>>, crossinline f: (Path, IOException) -> Assertion?): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>

package ch.tutteli.atrium.logic.creating.iterable.contains

interface IterableLikeContains

interface Checker : Contains.Checker
interface CheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.CheckerStep<T, S, IterableLikeContains.Checker, IterableLikeContains.EntryPointStep<E, T, S>>
interface CheckerStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>, IterableLikeContains.CheckerStepLogic<E, T, S>
interface CheckerStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.CheckerStepLogic<T, S, IterableLikeContains.Checker, IterableLikeContains.EntryPointStepLogic<E, T, S>>
interface Creator<T, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.EntryPointStep<E, T, S>, IterableLikeContains.EntryPointStepLogic<E, T, S>
interface EntryPointStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>

abstract val converter: (T) -> Iterable<E>
open fun <S2 : IterableLikeContains.SearchBehaviour> withSearchBehaviour(searchBehaviour: S2): IterableLikeContains.EntryPointStep<E, T, S2>

interface SearchBehaviour : Contains.SearchBehaviour

package ch.tutteli.atrium.logic.creating.iterable.contains.checkers

interface AtLeastChecker : AtLeastChecker, IterableLikeContains.Checker
interface AtMostChecker : AtMostChecker, IterableLikeContains.Checker
interface ExactlyChecker : ExactlyChecker, IterableLikeContains.Checker
interface NotChecker : NotChecker, IterableLikeContains.Checker

package ch.tutteli.atrium.logic.creating.iterable.contains.checkers.impl

class DefaultAtLeastChecker : AtLeastChecker, ContainsChecker

DefaultAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
val atLeastCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultAtMostChecker : AtMostChecker, ContainsChecker

DefaultAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
val atMostCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultExactlyChecker : ExactlyChecker, ContainsChecker

DefaultExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion
val exactlyCall: (Int) -> String
val nameContainsNotFun: String

class DefaultNotChecker : NotChecker

DefaultNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

package ch.tutteli.atrium.logic.creating.iterable.contains.creators

interface IterableLikeContainsAssertions

abstract fun <E : Any, T> entriesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T> entriesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E : Any, T> entriesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>): Assertion
abstract fun <E, T> valuesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T> valuesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T> valuesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

interface IterableLikeContainsInAnyOrderAssertions

abstract fun <E : Any, T> entries(checkerStepLogic: IterableLikeContains.CheckerStepLogic<out E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
abstract fun <E, T> values(checkerStepLogic: IterableLikeContains.CheckerStepLogic<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion

package ch.tutteli.atrium.logic.creating.iterable.contains.creators.impl

class DefaultIterableLikeContainsAssertions : IterableLikeContainsAssertions

DefaultIterableLikeContainsAssertions()
fun <E : Any, T> entriesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
fun <E : Any, T> entriesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
fun <E : Any, T> entriesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<out E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<(Expect<E>.() -> Unit)?>>): Assertion
fun <E, T> valuesInAnyOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
fun <E, T> valuesInOrderOnly(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
fun <E, T> valuesInOrderOnlyGrouped(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion

class DefaultIterableLikeContainsInAnyOrderAssertions : IterableLikeContainsInAnyOrderAssertions

DefaultIterableLikeContainsInAnyOrderAssertions()
fun <E : Any, T> entries(checkerStepLogic: IterableLikeContains.CheckerStepLogic<out E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<(Expect<E>.() -> Unit)?>): Assertion
fun <E, T> values(checkerStepLogic: IterableLikeContains.CheckerStepLogic<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion

class InAnyOrderEntriesAssertionCreator<E : Any, T> : ContainsAssertionCreator<T, List<E?>, (Expect<E>.() -> Unit)?, IterableLikeContains.Checker>, IterableLikeContains.Creator<T, (Expect<E>.() -> Unit)?>

InAnyOrderEntriesAssertionCreator(converter: (T) -> Iterable<E?>, searchBehaviour: InAnyOrderSearchBehaviour, checkers: List<IterableLikeContains.Checker>)
protected val descriptionContains: Translatable
protected fun makeSubjectMultipleTimesConsumable(container: AssertionContainer<T>): AssertionContainer<List<E?>>
protected fun searchAndCreateAssertion(multiConsumableContainer: AssertionContainer<List<E?>>, searchCriterion: (Expect<E>.() -> Unit)?, featureFactory: (Int, Translatable) -> AssertionGroup): AssertionGroup

abstract class InAnyOrderOnlyAssertionCreator<E, T, in SC> : IterableLikeContains.Creator<T, SC>

InAnyOrderOnlyAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InAnyOrderOnlySearchBehaviour)
protected abstract fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: SC, list: MutableList<E?>): Pair<Boolean, Assertion>
fun createAssertionGroup(container: AssertionContainer<T>, searchCriteria: List<SC>): AssertionGroup

class InAnyOrderOnlyEntriesAssertionCreator<E : Any, T> : InAnyOrderOnlyAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>

InAnyOrderOnlyEntriesAssertionCreator(converter: (T) -> Iterable<E?>, searchBehaviour: InAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: (Expect<E>.() -> Unit)?, list: MutableList<E?>): Pair<Boolean, Assertion>

class InAnyOrderOnlyValuesAssertionCreator<E, T> : InAnyOrderOnlyAssertionCreator<E, T, E>

InAnyOrderOnlyValuesAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InAnyOrderOnlySearchBehaviour)
protected fun createAssertionForSearchCriterionAndRemoveMatchFromList(searchCriterion: E, list: MutableList<E?>): Pair<Boolean, Assertion>

class InAnyOrderValuesAssertionCreator<SC, T> : ContainsObjectsAssertionCreator<T, List<SC>, SC, InAnyOrderSearchBehaviour, IterableLikeContains.Checker>, IterableLikeContains.Creator<T, SC>

InAnyOrderValuesAssertionCreator(converter: (T) -> Iterable<SC>, searchBehaviour: InAnyOrderSearchBehaviour, checkers: List<IterableLikeContains.Checker>)
fun decorateAssertion(container: AssertionContainer<List<SC>>, featureAssertion: Assertion): List<Assertion>
protected val descriptionContains: Translatable
protected val descriptionNumberOfOccurrences: Translatable
protected fun getAssertionGroupType(): AssertionGroupType
protected val groupDescription: Translatable
protected fun makeSubjectMultipleTimesConsumable(container: AssertionContainer<T>): AssertionContainer<List<SC>>
protected fun search(multiConsumableContainer: AssertionContainer<List<SC>>, searchCriterion: SC): Int

abstract class InOrderOnlyAssertionCreator<E, T, SC> : InOrderOnlyBaseAssertionCreator<E, T, SC>, InOrderOnlyMatcher<E, SC>

InOrderOnlyAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InOrderOnlySearchBehaviour)
protected open fun Expect<List<E>>.addAssertionsAndReturnIndex(searchCriteria: List<SC>): Int

abstract class InOrderOnlyBaseAssertionCreator<E, T, SC> : IterableLikeContains.Creator<T, SC>

InOrderOnlyBaseAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: IterableLikeContains.SearchBehaviour)
protected abstract fun Expect<List<E>>.addAssertionsAndReturnIndex(searchCriteria: List<SC>): Int
fun createAssertionGroup(container: AssertionContainer<T>, searchCriteria: List<SC>): AssertionGroup

class InOrderOnlyEntriesAssertionCreator<E : Any, T> : InOrderOnlyAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>, InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>

InOrderOnlyEntriesAssertionCreator(converter: (T) -> Iterable<E?>, searchBehaviour: InOrderOnlySearchBehaviour)

class InOrderOnlyEntriesMatcher<E : Any> : InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>

InOrderOnlyEntriesMatcher()
fun elementAssertionCreator(maybeElement: Option<E?>, searchCriterion: (Expect<E>.() -> Unit)?): Assertion

abstract class InOrderOnlyGroupedAssertionCreator<E, T, SC> : InOrderOnlyBaseAssertionCreator<E, T, List<SC>>, InOrderOnlyMatcher<E, SC>

InOrderOnlyGroupedAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InOrderOnlyGroupedSearchBehaviour)
protected fun Expect<List<E>>.addAssertionsAndReturnIndex(searchCriteria: List<List<SC>>): Int
protected abstract fun Expect<List<E>>.addSublistAssertion(groupOfSearchCriteria: List<SC>): Unit

class InOrderOnlyGroupedEntriesAssertionCreator<E : Any, T> : InOrderOnlyGroupedAssertionCreator<E?, T, (Expect<E>.() -> Unit)?>, InOrderOnlyMatcher<E?, (Expect<E>.() -> Unit)?>

InOrderOnlyGroupedEntriesAssertionCreator(converter: (T) -> Iterable<E?>, searchBehaviour: InOrderOnlyGroupedSearchBehaviour)
protected fun Expect<List<E?>>.addSublistAssertion(groupOfSearchCriteria: List<(Expect<E>.() -> Unit)?>): Unit

class InOrderOnlyGroupedValuesAssertionCreator<E, T> : InOrderOnlyGroupedAssertionCreator<E, T, E>, InOrderOnlyMatcher<E, E>

InOrderOnlyGroupedValuesAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InOrderOnlyGroupedSearchBehaviour)
protected fun Expect<List<E>>.addSublistAssertion(groupOfSearchCriteria: List<E>): Unit

interface InOrderOnlyMatcher<E, SC>

open fun Expect<List<E>>.addSingleEntryAssertion(currentIndex: Int, searchCriterion: SC, translatableIndex: DescriptionIterableAssertion): Unit
abstract fun elementAssertionCreator(maybeElement: Option<E>, searchCriterion: SC): Assertion

class InOrderOnlyValueMatcher<E> : InOrderOnlyMatcher<E, E>

InOrderOnlyValueMatcher()
fun elementAssertionCreator(maybeElement: Option<E>, searchCriterion: E): Assertion

class InOrderOnlyValuesAssertionCreator<E, T> : InOrderOnlyAssertionCreator<E, T, E>, InOrderOnlyMatcher<E, E>

InOrderOnlyValuesAssertionCreator(converter: (T) -> Iterable<E>, searchBehaviour: InOrderOnlySearchBehaviour)

fun <E, T> turnSubjectToList(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): AssertionContainer<List<E>>

package ch.tutteli.atrium.logic.creating.iterable.contains.searchbehaviours

interface InAnyOrderOnlySearchBehaviour : IterableLikeContains.SearchBehaviour
interface InAnyOrderSearchBehaviour : IterableLikeContains.SearchBehaviour
interface InOrderOnlyGroupedSearchBehaviour : IterableLikeContains.SearchBehaviour
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
interface InOrderOnlySearchBehaviour : IterableLikeContains.SearchBehaviour
interface InOrderSearchBehaviour : IterableLikeContains.SearchBehaviour
interface NoOpSearchBehaviour : IterableLikeContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

interface NotSearchBehaviour : InAnyOrderSearchBehaviour

package ch.tutteli.atrium.logic.creating.iterable.contains.searchbehaviours.impl

class InAnyOrderOnlySearchBehaviourImpl : InAnyOrderOnlySearchBehaviour

InAnyOrderOnlySearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InAnyOrderSearchBehaviourImpl : InAnyOrderSearchBehaviour

InAnyOrderSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderOnlyGroupedSearchBehaviourImpl : InOrderOnlyGroupedSearchBehaviour

InOrderOnlyGroupedSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderOnlyGroupedWithinSearchBehaviourImpl : InOrderOnlyGroupedWithinSearchBehaviour

InOrderOnlyGroupedWithinSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderOnlySearchBehaviourImpl : InOrderOnlySearchBehaviour

InOrderOnlySearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderSearchBehaviourImpl : InOrderSearchBehaviour

InOrderSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class NoOpSearchBehaviourImpl : NoOpSearchBehaviour

NoOpSearchBehaviourImpl()

class NotSearchBehaviourImpl : NotSearchBehaviour

NotSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

package ch.tutteli.atrium.logic.creating.iterable.contains.steps

val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, InOrderSearchBehaviour>.andOnly: IterableLikeContains.EntryPointStep<E, T, InOrderOnlySearchBehaviour>
interface AtLeastCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.atLeastCheckerStep(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): AtLeastCheckerStep<E, T, S>
interface AtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.atMostCheckerStep(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): AtMostCheckerStep<E, T, S>
interface ButAtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> WithTimesCheckerStepLogic<E, T, S>.butAtMostCheckerStep(times: Int, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String, atMostCall: (Int) -> String): ButAtMostCheckerStep<E, T, S>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, InAnyOrderSearchBehaviour>.butOnly: IterableLikeContains.EntryPointStep<E, T, InAnyOrderOnlySearchBehaviour>
interface ExactlyCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.exactlyCheckerStep(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String): ExactlyCheckerStep<E, T, S>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlySearchBehaviour>.grouped: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedSearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, NoOpSearchBehaviour>.inAnyOrder: IterableLikeContains.EntryPointStep<E, T, InAnyOrderSearchBehaviour>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, NoOpSearchBehaviour>.inOrder: IterableLikeContains.EntryPointStep<E, T, InOrderSearchBehaviour>
class NoOpCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStepInternal<E, T, S>

NoOpCheckerStep(entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, S>)
val checkers: List<IterableLikeContains.Checker>
val entryPointStepLogic: IterableLikeContains.EntryPointStepLogic<E, T, S>

interface NotCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.notCheckerStep(): NotCheckerStep<E, T, S>
interface NotOrAtMostCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
fun <E, T, S : IterableLikeContains.SearchBehaviour> IterableLikeContains.EntryPointStepLogic<E, T, S>.notOrAtMostCheckerStep(times: Int, nameContainsNotFun: String, notOrAtMostCall: (Int) -> String): NotOrAtMostCheckerStep<E, T, S>
val <E, T> IterableLikeContains.EntryPointStepLogic<E, T, InOrderOnlyGroupedSearchBehaviour>.within: IterableLikeContains.EntryPointStep<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
interface WithTimesCheckerStep<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStep<E, T, S>
interface WithTimesCheckerStepInternal<E, T, out S : IterableLikeContains.SearchBehaviour> : WithTimesCheckerStep<E, T, S>, WithTimesCheckerStepLogic<E, T, S>, IterableLikeContains.CheckerStepInternal<E, T, S>
interface WithTimesCheckerStepLogic<E, T, out S : IterableLikeContains.SearchBehaviour> : IterableLikeContains.CheckerStepLogic<E, T, S>

abstract val times: Int

package ch.tutteli.atrium.logic.creating.iterable.contains.steps.impl

fun <T> atLeastChecker(container: AssertionContainer<T>, times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String): AtLeastChecker
fun <T> atMostChecker(container: AssertionContainer<T>, times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String): AtMostChecker
class EntryPointStepImpl<E, T, out S : IterableLikeContains.SearchBehaviour> : EntryPointStepImpl<T, S>, IterableLikeContains.EntryPointStepInternal<E, T, S>

EntryPointStepImpl(container: AssertionContainer<T>, converter: (T) -> Iterable<E>, searchBehaviour: S)
val converter: (T) -> Iterable<E>

package ch.tutteli.atrium.logic.creating.maplike.contains

interface MapLikeContains

interface Checker : Contains.Checker
interface Creator<T, in SC> : Contains.Creator<T, SC>
interface EntryPointStep<K, V, T, out S : MapLikeContains.SearchBehaviour> : Contains.EntryPointStep<T, S>
interface EntryPointStepInternal<K, V, T, out S : MapLikeContains.SearchBehaviour> : MapLikeContains.EntryPointStep<K, V, T, S>, MapLikeContains.EntryPointStepLogic<K, V, T, S>
interface EntryPointStepLogic<K, V, T, out S : MapLikeContains.SearchBehaviour> : Contains.EntryPointStepLogic<T, S>

abstract val converter: (T) -> Map<out K, V>
open fun <S2 : MapLikeContains.SearchBehaviour> withSearchBehaviour(searchBehaviour: S2): MapLikeContains.EntryPointStep<K, V, T, S2>

interface SearchBehaviour : Contains.SearchBehaviour

package ch.tutteli.atrium.logic.creating.maplike.contains.checkers

interface AtLeastChecker : AtLeastChecker, MapLikeContains.Checker
interface AtMostChecker : AtMostChecker, MapLikeContains.Checker
interface ExactlyChecker : ExactlyChecker, MapLikeContains.Checker
interface NotChecker : NotChecker, MapLikeContains.Checker

package ch.tutteli.atrium.logic.creating.maplike.contains.checkers.impl

class DefaultAtLeastChecker : AtLeastChecker, ContainsChecker

DefaultAtLeastChecker(times: Int, nameContainsNotFun: String, atLeastCall: (Int) -> String)
val atLeastCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultAtMostChecker : AtMostChecker, ContainsChecker

DefaultAtMostChecker(times: Int, nameContainsNotFun: String, atMostCall: (Int) -> String)
val atMostCall: (Int) -> String
fun createAssertion(foundNumberOfTimes: Int): Assertion
val nameContainsNotFun: String

class DefaultExactlyChecker : ExactlyChecker, ContainsChecker

DefaultExactlyChecker(times: Int, nameContainsNotFun: String, exactlyCall: (Int) -> String)
fun createAssertion(foundNumberOfTimes: Int): Assertion
val exactlyCall: (Int) -> String
val nameContainsNotFun: String

class DefaultNotChecker : NotChecker

DefaultNotChecker()
fun createAssertion(foundNumberOfTimes: Int): Assertion

package ch.tutteli.atrium.logic.creating.maplike.contains.creators

interface MapLikeContainsAssertions

abstract fun <K, V, T> keyValuePairsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V, T> keyValuePairsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V, T> keyValuePairsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderSearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
abstract fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion

package ch.tutteli.atrium.logic.creating.maplike.contains.creators.impl

class DefaultMapLikeContainsAssertions : MapLikeContainsAssertions

DefaultMapLikeContainsAssertions()
fun <K, V, T> keyValuePairsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V, T> keyValuePairsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V, T> keyValuePairsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, V, T, InOrderOnlySearchBehaviour>, keyValuePairs: List<Pair<K, V>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInAnyOrder(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderSearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInAnyOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InAnyOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion
fun <K, V : Any, T> keyWithValueAssertionsInOrderOnly(entryPointStepLogic: MapLikeContains.EntryPointStepLogic<K, out V?, T, InOrderOnlySearchBehaviour>, valueType: KClass<V>, keyValues: List<Pair<K, (Expect<V>.() -> Unit)?>>): Assertion

package ch.tutteli.atrium.logic.creating.maplike.contains.searchbehaviours

interface InAnyOrderOnlySearchBehaviour : MapLikeContains.SearchBehaviour
interface InAnyOrderSearchBehaviour : MapLikeContains.SearchBehaviour
interface InOrderOnlySearchBehaviour : MapLikeContains.SearchBehaviour
interface InOrderSearchBehaviour : MapLikeContains.SearchBehaviour
interface NoOpSearchBehaviour : MapLikeContains.SearchBehaviour

open fun decorateDescription(description: Translatable): Translatable

package ch.tutteli.atrium.logic.creating.maplike.contains.searchbehaviours.impl

class InAnyOrderOnlySearchBehaviourImpl : InAnyOrderOnlySearchBehaviour

InAnyOrderOnlySearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InAnyOrderSearchBehaviourImpl : InAnyOrderSearchBehaviour

InAnyOrderSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderOnlySearchBehaviourImpl : InOrderOnlySearchBehaviour

InOrderOnlySearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class InOrderSearchBehaviourImpl : InOrderSearchBehaviour

InOrderSearchBehaviourImpl()
fun decorateDescription(description: Translatable): Translatable

class NoOpSearchBehaviourImpl : NoOpSearchBehaviour

NoOpSearchBehaviourImpl()

package ch.tutteli.atrium.logic.creating.maplike.contains.steps

val <K, V, T> MapLikeContains.EntryPointStepLogic<K, V, T, InOrderSearchBehaviour>.andOnly: MapLikeContains.EntryPointStep<K, V, T, InOrderOnlySearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStepLogic<K, V, T, InAnyOrderSearchBehaviour>.butOnly: MapLikeContains.EntryPointStep<K, V, T, InAnyOrderOnlySearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStepLogic<K, V, T, NoOpSearchBehaviour>.inAnyOrder: MapLikeContains.EntryPointStep<K, V, T, InAnyOrderSearchBehaviour>
val <K, V, T> MapLikeContains.EntryPointStepLogic<K, V, T, NoOpSearchBehaviour>.inOrder: MapLikeContains.EntryPointStep<K, V, T, InOrderSearchBehaviour>

package ch.tutteli.atrium.logic.creating.maplike.contains.steps.impl

class EntryPointStepImpl<K, V, T, out S : MapLikeContains.SearchBehaviour> : EntryPointStepImpl<T, S>, MapLikeContains.EntryPointStepInternal<K, V, T, S>

EntryPointStepImpl(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, searchBehaviour: S)
val converter: (T) -> Map<out K, V>

package ch.tutteli.atrium.logic.creating.transformers

class FailureHandlerAdapter<T, R1, R> : SubjectChanger.FailureHandler<T, R>

FailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1)
fun createAssertion(container: AssertionContainer<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion
val failureHandler: SubjectChanger.FailureHandler<R1, R>
val map: (T) -> R1

interface FeatureExtractor

abstract fun <T, R> extract(container: AssertionContainer<T>, description: Translatable, representationForFailure: Any, featureExtraction: (T) -> Option<R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>

val <T> AssertionContainer<T>.featureExtractor: FeatureExtractor
interface FeatureExtractorBuilder

interface DescriptionStep<T>

abstract val container: AssertionContainer<T>
operator fun <T> invoke(container: AssertionContainer<T>): FeatureExtractorBuilder.DescriptionStep<T>
open fun methodCall(methodName: String, vararg arguments: Any?): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
open fun withDescription(description: String): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
abstract fun withDescription(translatable: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>

interface ExecutionStep<T, R> : TransformationExecutionStep<T, R, FeatureExpect<T, R>>

operator fun <T, R> invoke(container: AssertionContainer<T>, action: (AssertionContainer<T>) -> FeatureExpect<T, R>, actionAndApply: (AssertionContainer<T>, Expect<R>.() -> Unit) -> Expect<R>): FeatureExtractorBuilder.ExecutionStep<T, R>

interface FeatureExtractionStep<T>

abstract val container: AssertionContainer<T>
abstract val description: Translatable
operator fun <T> invoke(container: AssertionContainer<T>, description: Translatable, representationForFailure: Any): FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract val representationForFailure: Any
abstract fun <R> withFeatureExtraction(extraction: (subject: T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>

interface FinalStep<T, R>

abstract fun build(): FeatureExtractorBuilder.ExecutionStep<T, R>
abstract val featureExpectOptions: FeatureExpectOptions<R>?
abstract val featureExtraction: (T) -> Option<R>
abstract val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
operator fun <T, R> invoke(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExtractorBuilder.FinalStep<T, R>

operator fun <T> invoke(assertionContainer: AssertionContainer<T>): FeatureExtractorBuilder.DescriptionStep<T>
interface OptionsStep<T, R>

abstract val featureExtraction: (T) -> Option<R>
abstract val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
operator fun <T, R> invoke(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>
open fun withOptions(configuration: FeatureExpectOptionsChooser<R>.() -> Unit): FeatureExtractorBuilder.FinalStep<T, R>
abstract fun withOptions(expectOptions: FeatureExpectOptions<R>): FeatureExtractorBuilder.FinalStep<T, R>
abstract fun withoutOptions(): FeatureExtractorBuilder.FinalStep<T, R>

interface RepresentationInCaseOfFailureStep<T>

abstract val container: AssertionContainer<T>
abstract val description: Translatable
operator fun <T> invoke(container: AssertionContainer<T>, description: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>
open fun withRepresentationForFailure(representationProvider: () -> Any?): FeatureExtractorBuilder.FeatureExtractionStep<T>
abstract fun withRepresentationForFailure(representation: Any): FeatureExtractorBuilder.FeatureExtractionStep<T>

interface SubjectChanger

interface FailureHandler<T, R>

abstract fun createAssertion(container: AssertionContainer<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion

abstract fun <T, R> reported(container: AssertionContainer<T>, description: Translatable, representation: Any, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>): Expect<R>
abstract fun <T, R> unreported(container: AssertionContainer<T>, transformation: (T) -> R): Expect<R>

val <T> AssertionContainer<T>.subjectChanger: SubjectChanger
interface SubjectChangerBuilder

interface DescriptionRepresentationStep<T>

abstract val container: AssertionContainer<T>
open fun <TSub : Any> downCastTo(subType: KClass<TSub>): SubjectChangerBuilder.FailureHandlerStep<T, TSub>
operator fun <T> invoke(container: AssertionContainer<T>): SubjectChangerBuilder.DescriptionRepresentationStep<T>
open fun withDescriptionAndRepresentation(description: String, representation: Any?): SubjectChangerBuilder.TransformationStep<T>
abstract fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): SubjectChangerBuilder.TransformationStep<T>

interface ExecutionStep<T, R> : TransformationExecutionStep<T, R, Expect<R>>

operator fun <T, R> invoke(container: AssertionContainer<T>, action: (AssertionContainer<T>) -> Expect<R>, actionAndApply: (AssertionContainer<T>, Expect<R>.() -> Unit) -> Expect<R>): SubjectChangerBuilder.ExecutionStep<T, R>

interface FailureHandlerStep<T, R>

open fun build(): SubjectChangerBuilder.ExecutionStep<T, R>
operator fun <T, R> invoke(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerStep<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>
abstract fun withDefaultFailureHandler(): SubjectChangerBuilder.FinalStep<T, R>
abstract fun withFailureHandler(failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
open fun <R1> withFailureHandlerAdapter(failureHandler: SubjectChanger.FailureHandler<R1, R>, map: (T) -> R1): SubjectChangerBuilder.FinalStep<T, R>

interface FinalStep<T, R>

abstract fun build(): SubjectChangerBuilder.ExecutionStep<T, R>
abstract val failureHandler: SubjectChanger.FailureHandler<T, R>
operator fun <T, R> invoke(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>
abstract val transformation: (T) -> Option<R>
abstract val transformationStep: SubjectChangerBuilder.TransformationStep<T>

operator fun <T> invoke(container: AssertionContainer<T>): SubjectChangerBuilder.KindStep<T>
interface KindStep<T>

abstract val container: AssertionContainer<T>
abstract fun reportBuilder(): SubjectChangerBuilder.DescriptionRepresentationStep<T>
open fun <R> unreported(transformation: (T) -> R): Expect<R>

interface TransformationStep<T>

abstract val container: AssertionContainer<T>
abstract val description: Translatable
operator fun <T> invoke(container: AssertionContainer<T>, description: Translatable, representation: Any): SubjectChangerBuilder.TransformationStep<T>
abstract val representation: Any
abstract fun <R> withTransformation(transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerStep<T, R>

interface TransformationExecutionStep<T, R, E : Expect<R>>

abstract fun collect(assertionCreator: Expect<R>.() -> Unit): Assertion
abstract fun collectAndAppend(assertionCreator: Expect<R>.() -> Unit): Expect<T>
abstract fun transform(): E
abstract fun transformAndAppend(assertionCreator: Expect<R>.() -> Unit): Expect<R>

package ch.tutteli.atrium.logic.creating.transformers.impl

abstract class BaseTransformationExecutionStep<T, R, E : Expect<R>> : TransformationExecutionStep<T, R, E>

BaseTransformationExecutionStep(container: AssertionContainer<T>, action: AssertionContainer<T>.() -> E, actionAndApply: AssertionContainer<T>.(Expect<R>.() -> Unit) -> Expect<R>)
protected val action: AssertionContainer<T>.() -> E
protected val actionAndApply: AssertionContainer<T>.(Expect<R>.() -> Unit) -> Expect<R>
fun collect(assertionCreator: Expect<R>.() -> Unit): Assertion
fun collectAndAppend(assertionCreator: Expect<R>.() -> Unit): Expect<T>
protected val container: AssertionContainer<T>
fun transform(): E
fun transformAndAppend(assertionCreator: Expect<R>.() -> Unit): Expect<R>

expect fun createAdditionalHints(throwable: Throwable): List<Assertion>
class DefaultFeatureExtractor : FeatureExtractor

DefaultFeatureExtractor()
fun <T, R> extract(container: AssertionContainer<T>, description: Translatable, representationForFailure: Any, featureExtraction: (T) -> Option<R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>, featureExpectOptions: FeatureExpectOptions<R>): FeatureExpect<T, R>

class DefaultSubjectChanger : SubjectChanger

DefaultSubjectChanger()
fun <T, R> reported(container: AssertionContainer<T>, description: Translatable, representation: Any, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>, maybeSubAssertions: Option<Expect<R>.() -> Unit>): Expect<R>
fun <T, R> unreported(container: AssertionContainer<T>, transformation: (T) -> R): Expect<R>

class ThrowableThrownFailureHandler<T : Throwable?, R> : SubjectChanger.FailureHandler<T, R>

ThrowableThrownFailureHandler()
fun createAssertion(container: AssertionContainer<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion
fun createChildHint(throwable: Throwable, child: Throwable, childDescription: Translatable): AssertionGroup
fun propertiesOfThrowable(throwable: Throwable, explanation: Assertion = createExplanation(throwable)): AssertionGroup

package ch.tutteli.atrium.logic.creating.transformers.impl.featureextractor

class DescriptionStepImpl<T> : FeatureExtractorBuilder.DescriptionStep<T>

DescriptionStepImpl(container: AssertionContainer<T>)
val container: AssertionContainer<T>
fun withDescription(translatable: Translatable): FeatureExtractorBuilder.RepresentationInCaseOfFailureStep<T>

class ExecutionStepImpl<T, R> : FeatureExtractorBuilder.ExecutionStep<T, R>, BaseTransformationExecutionStep<T, R, FeatureExpect<T, R>>

ExecutionStepImpl(container: AssertionContainer<T>, action: AssertionContainer<T>.() -> FeatureExpect<T, R>, actionAndApply: AssertionContainer<T>.(Expect<R>.() -> Unit) -> Expect<R>)

class FeatureExtractionStepImpl<T> : FeatureExtractorBuilder.FeatureExtractionStep<T>

FeatureExtractionStepImpl(container: AssertionContainer<T>, description: Translatable, representationForFailure: Any)
val container: AssertionContainer<T>
val description: Translatable
val representationForFailure: Any
fun <R> withFeatureExtraction(extraction: (T) -> Option<R>): FeatureExtractorBuilder.OptionsStep<T, R>

class FinalStepImpl<T, R> : FeatureExtractorBuilder.FinalStep<T, R>

FinalStepImpl(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>, featureExpectOptions: FeatureExpectOptions<R>)
fun build(): FeatureExtractorBuilder.ExecutionStep<T, R>
val featureExpectOptions: FeatureExpectOptions<R>
val featureExtraction: (T) -> Option<R>
val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>

class OptionsStepImpl<T, R> : FeatureExtractorBuilder.OptionsStep<T, R>

OptionsStepImpl(featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>, featureExtraction: (T) -> Option<R>)
val featureExtraction: (T) -> Option<R>
val featureExtractionStep: FeatureExtractorBuilder.FeatureExtractionStep<T>
fun withOptions(expectOptions: FeatureExpectOptions<R>): FeatureExtractorBuilder.FinalStep<T, R>
fun withoutOptions(): FeatureExtractorBuilder.FinalStep<T, R>

package ch.tutteli.atrium.logic.creating.transformers.impl.subjectchanger

class DefaultFailureHandlerImpl<T, R> : SubjectChanger.FailureHandler<T, R>

DefaultFailureHandlerImpl()
fun createAssertion(container: AssertionContainer<T>, descriptiveAssertion: Assertion, maybeAssertionCreator: Option<Expect<R>.() -> Unit>): Assertion

class DescriptionRepresentationStepImpl<T> : SubjectChangerBuilder.DescriptionRepresentationStep<T>

DescriptionRepresentationStepImpl(container: AssertionContainer<T>)
val container: AssertionContainer<T>
fun withDescriptionAndRepresentation(description: Translatable, representation: Any?): SubjectChangerBuilder.TransformationStep<T>

class ExecutionStepImpl<T, R> : SubjectChangerBuilder.ExecutionStep<T, R>, BaseTransformationExecutionStep<T, R, Expect<R>>

ExecutionStepImpl(container: AssertionContainer<T>, action: AssertionContainer<T>.() -> Expect<R>, actionAndApply: AssertionContainer<T>.(Expect<R>.() -> Unit) -> Expect<R>)

class FailureHandlerStepImpl<T, R> : SubjectChangerBuilder.FailureHandlerStep<T, R>

FailureHandlerStepImpl(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>)
val transformation: (T) -> Option<R>
val transformationStep: SubjectChangerBuilder.TransformationStep<T>
fun withDefaultFailureHandler(): SubjectChangerBuilder.FinalStep<T, R>
fun withFailureHandler(failureHandler: SubjectChanger.FailureHandler<T, R>): SubjectChangerBuilder.FinalStep<T, R>

class FinalStepImpl<T, R> : SubjectChangerBuilder.FinalStep<T, R>

FinalStepImpl(transformationStep: SubjectChangerBuilder.TransformationStep<T>, transformation: (T) -> Option<R>, failureHandler: SubjectChanger.FailureHandler<T, R>)
fun build(): SubjectChangerBuilder.ExecutionStep<T, R>
val failureHandler: SubjectChanger.FailureHandler<T, R>
val transformation: (T) -> Option<R>
val transformationStep: SubjectChangerBuilder.TransformationStep<T>

class KindStepImpl<T> : SubjectChangerBuilder.KindStep<T>

KindStepImpl(container: AssertionContainer<T>)
val container: AssertionContainer<T>
fun reportBuilder(): SubjectChangerBuilder.DescriptionRepresentationStep<T>

class TransformationStepImpl<T> : SubjectChangerBuilder.TransformationStep<T>

TransformationStepImpl(container: AssertionContainer<T>, description: Translatable, representation: Any)
val container: AssertionContainer<T>
val description: Translatable
val representation: Any
fun <R> withTransformation(transformation: (T) -> Option<R>): SubjectChangerBuilder.FailureHandlerStep<T, R>

package ch.tutteli.atrium.logic.creating.typeutils

typealias CharSequenceOrNumberOrChar = Any
typealias CollectionLike = Any
typealias IterableLike = Any
interface IterableLikeToIterableTransformer

abstract fun supportedTypes(): List<String>
abstract fun <T> unsafeTransform(iterableLike: IterableLike): Iterable<T>

val AssertionContainer<*>.iterableLikeToIterableTransformer: IterableLikeToIterableTransformer
typealias MapLike = Any
interface MapLikeToIterablePairTransformer

abstract fun supportedTypes(): List<String>
abstract fun <K, V> unsafeTransform(mapLike: MapLike): List<Pair<K, V>>

val AssertionContainer<*>.mapLikeToMapTransformer: MapLikeToIterablePairTransformer

package ch.tutteli.atrium.logic.creating.typeutils.impl

class DefaultIterableLikeToIterableTransformer : IterableLikeToIterableTransformer

DefaultIterableLikeToIterableTransformer()
fun supportedTypes(): List<String>
fun <T> unsafeTransform(iterableLike: IterableLike): Iterable<T>

class DefaultMapLikeToIterablePairTransformer : MapLikeToIterablePairTransformer

DefaultMapLikeToIterablePairTransformer(container: AssertionContainer<*>)
fun supportedTypes(): List<String>
fun <K, V> unsafeTransform(mapLike: IterableLike): List<Pair<K, V>>

package ch.tutteli.atrium.logic.impl

class DefaultAnyAssertions : AnyAssertions

DefaultAnyAssertions()
fun <T> because(container: AssertionContainer<T>, reason: String, assertionCreator: Expect<T>.() -> Unit): Assertion
fun <T, TSub : Any> isA(container: AssertionContainer<T>, subType: KClass<TSub>): SubjectChangerBuilder.ExecutionStep<T, TSub>
fun <T> isNotIn(container: AssertionContainer<T>, expected: Iterable<T>): Assertion
fun <T> isNotSameAs(container: AssertionContainer<T>, expected: T): Assertion
fun <T> isSameAs(container: AssertionContainer<T>, expected: T): Assertion
fun <T> notToBe(container: AssertionContainer<T>, expected: T): Assertion
fun <T : Any> notToBeNullButOfType(container: AssertionContainer<T?>, subType: KClass<T>): SubjectChangerBuilder.ExecutionStep<T?, T>
fun <T> toBe(container: AssertionContainer<T>, expected: T): Assertion
fun <T> toBeNull(container: AssertionContainer<T>): Assertion
fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, type: KClass<T>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion
fun <T : Any> toBeNullIfNullGivenElse(container: AssertionContainer<T?>, assertionCreatorOrNull: (Expect<T>.() -> Unit)?): Assertion

class DefaultBigDecimalAssertions : BigDecimalAssertions

DefaultBigDecimalAssertions()
fun <T : BigDecimal> isEqualIncludingScale(container: AssertionContainer<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
fun <T : BigDecimal> isNotEqualIncludingScale(container: AssertionContainer<T>, expected: T): Assertion
fun <T : BigDecimal> isNotNumericallyEqualTo(container: AssertionContainer<T>, expected: T): Assertion
fun <T : BigDecimal> isNumericallyEqualTo(container: AssertionContainer<T>, expected: T): Assertion

class DefaultCharSequenceAssertions : CharSequenceAssertions

DefaultCharSequenceAssertions()
fun <T : CharSequence> containsBuilder(container: AssertionContainer<T>): CharSequenceContains.EntryPointStep<T, NoOpSearchBehaviour>
fun <T : CharSequence> containsNotBuilder(container: AssertionContainer<T>): NotCheckerStep<T, NotSearchBehaviour>
fun <T : CharSequence> endsNotWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
fun <T : CharSequence> endsWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
fun <T : CharSequence> isEmpty(container: AssertionContainer<T>): Assertion
fun <T : CharSequence> isNotBlank(container: AssertionContainer<T>): Assertion
fun <T : CharSequence> isNotEmpty(container: AssertionContainer<T>): Assertion
fun <T : CharSequence> matches(container: AssertionContainer<T>, expected: Regex): Assertion
fun <T : CharSequence> mismatches(container: AssertionContainer<T>, expected: Regex): Assertion
fun <T : CharSequence> startsNotWith(container: AssertionContainer<T>, expected: CharSequence): Assertion
fun <T : CharSequence> startsWith(container: AssertionContainer<T>, expected: CharSequence): Assertion

class DefaultChronoLocalDateAssertions : ChronoLocalDateAssertions

DefaultChronoLocalDateAssertions()
fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDate): Assertion
fun <T : ChronoLocalDate> isEqual(container: AssertionContainer<T>, expected: String): Assertion

class DefaultChronoLocalDateTimeAssertions : ChronoLocalDateTimeAssertions

DefaultChronoLocalDateTimeAssertions()
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoLocalDateTime<*>): Assertion
fun <T : ChronoLocalDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion

class DefaultChronoZonedDateTimeAssertions : ChronoZonedDateTimeAssertions

DefaultChronoZonedDateTimeAssertions()
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfter(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isAfterOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBefore(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isBeforeOrEqual(container: AssertionContainer<T>, expected: String): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: ChronoZonedDateTime<*>): Assertion
fun <T : ChronoZonedDateTime<out ChronoLocalDate>> isEqual(container: AssertionContainer<T>, expected: String): Assertion

class DefaultCollectionLikeAssertions : CollectionLikeAssertions

DefaultCollectionLikeAssertions()
fun <T> isEmpty(container: AssertionContainer<T>, converter: (T) -> Collection<*>): Assertion
fun <T> isNotEmpty(container: AssertionContainer<T>, converter: (T) -> Collection<*>): Assertion
fun <T> size(container: AssertionContainer<T>, converter: (T) -> Collection<*>): FeatureExtractorBuilder.ExecutionStep<T, Int>

class DefaultComparableAssertions : ComparableAssertions

DefaultComparableAssertions()
fun <T1 : Comparable<T2>, T2> isEqualComparingTo(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isGreaterThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isGreaterThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isLessThan(container: AssertionContainer<T1>, expected: T2): Assertion
fun <T1 : Comparable<T2>, T2> isLessThanOrEqual(container: AssertionContainer<T1>, expected: T2): Assertion

class DefaultFeatureAssertions : FeatureAssertions

DefaultFeatureAssertions()
fun <T, R> f0(container: AssertionContainer<T>, f: KFunction1<T, R>): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, R> f1(container: AssertionContainer<T>, f: KFunction2<T, A1, R>, a1: A1): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, R> f2(container: AssertionContainer<T>, f: KFunction3<T, A1, A2, R>, a1: A1, a2: A2): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, R> f3(container: AssertionContainer<T>, f: KFunction4<T, A1, A2, A3, R>, a1: A1, a2: A2, a3: A3): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, A4, R> f4(container: AssertionContainer<T>, f: KFunction5<T, A1, A2, A3, A4, R>, a1: A1, a2: A2, a3: A3, a4: A4): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, A1, A2, A3, A4, A5, R> f5(container: AssertionContainer<T>, f: KFunction6<T, A1, A2, A3, A4, A5, R>, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, R> manualFeature(container: AssertionContainer<T>, description: Translatable, provider: T.() -> R): FeatureExtractorBuilder.ExecutionStep<T, R>
fun <T, TProperty> property(container: AssertionContainer<T>, property: KProperty1<in T, TProperty>): FeatureExtractorBuilder.ExecutionStep<T, TProperty>

class DefaultFloatingPointAssertions : FloatingPointAssertions

DefaultFloatingPointAssertions()
fun toBeWithErrorTolerance(container: AssertionContainer<Float>, expected: Float, tolerance: Float): Assertion
fun toBeWithErrorTolerance(container: AssertionContainer<Double>, expected: Double, tolerance: Double): Assertion

class DefaultFloatingPointJvmAssertions : FloatingPointJvmAssertions

DefaultFloatingPointJvmAssertions()
fun <T : BigDecimal> toBeWithErrorTolerance(container: AssertionContainer<T>, expected: BigDecimal, tolerance: BigDecimal): Assertion

class DefaultFun0Assertions : Fun0Assertions

DefaultFun0Assertions()
fun <R, T : () -> R> notToThrow(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<*, R>
fun <TExpected : Throwable> toThrow(container: AssertionContainer<() -> Any?>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<*, TExpected>

class DefaultIterableLikeAssertions : IterableLikeAssertions

DefaultIterableLikeAssertions()
fun <T, E> all(container: AssertionContainer<T>, converter: (T) -> Iterable<E?>, assertionCreatorOrNull: (Expect<E>.() -> Unit)?): Assertion
fun <T, E> builderContainsInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): IterableLikeContains.EntryPointStep<E, T, NoOpSearchBehaviour>
fun <T, E> builderContainsNotInIterableLike(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): NotCheckerStep<E, T, NotSearchBehaviour>
fun <T, E> containsNoDuplicates(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E> hasNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E> hasNotNext(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): Assertion
fun <T, E : Comparable<E>> max(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>
fun <T, E : Comparable<E>> min(container: AssertionContainer<T>, converter: (T) -> Iterable<E>): FeatureExtractorBuilder.ExecutionStep<T, E>

class DefaultIteratorAssertions : IteratorAssertions

DefaultIteratorAssertions()
fun <E, T : Iterator<E>> hasNext(container: AssertionContainer<T>): Assertion
fun <E, T : Iterator<E>> hasNotNext(container: AssertionContainer<T>): Assertion

class DefaultListAssertions : ListAssertions

DefaultListAssertions()
fun <E, T : List<E>> get(container: AssertionContainer<T>, index: Int): FeatureExtractorBuilder.ExecutionStep<T, E>

class DefaultLocalDateAssertions : LocalDateAssertions

DefaultLocalDateAssertions()
fun day(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>
fun dayOfWeek(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, DayOfWeek>
fun month(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>
fun year(container: AssertionContainer<LocalDate>): FeatureExtractorBuilder.ExecutionStep<LocalDate, Int>

class DefaultLocalDateTimeAssertions : LocalDateTimeAssertions

DefaultLocalDateTimeAssertions()
fun day(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>
fun dayOfWeek(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, DayOfWeek>
fun month(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>
fun year(container: AssertionContainer<LocalDateTime>): FeatureExtractorBuilder.ExecutionStep<LocalDateTime, Int>

class DefaultMapEntryAssertions : MapEntryAssertions

DefaultMapEntryAssertions()
fun <K, V, T : Entry<K, V>> isKeyValue(container: AssertionContainer<T>, key: K, value: V): Assertion
fun <K, T : Entry<K, *>> key(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
fun <V, T : Entry<*, V>> value(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>

class DefaultMapLikeAssertions : MapLikeAssertions

DefaultMapLikeAssertions()
fun <T, K, V> builderContainsInMapLike(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>): MapLikeContains.EntryPointStep<K, V, T, NoOpSearchBehaviour>
fun <K, T> containsKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
fun <K, T> containsNotKey(container: AssertionContainer<T>, converter: (T) -> Map<out K, *>, key: K): Assertion
fun <K, V, T> getExisting(container: AssertionContainer<T>, converter: (T) -> Map<out K, V>, key: K): FeatureExtractorBuilder.ExecutionStep<T, V>

class DefaultOptionalAssertions : OptionalAssertions

DefaultOptionalAssertions()
fun <T : Optional<*>> isEmpty(container: AssertionContainer<T>): Assertion
fun <E, T : Optional<E>> isPresent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, E>

class DefaultPairAssertions : PairAssertions

DefaultPairAssertions()
fun <K, T : Pair<K, *>> first(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, K>
fun <V, T : Pair<*, V>> second(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, V>

class DefaultPathAssertions : PathAssertions

DefaultPathAssertions()
fun <T : Path> endsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> endsWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> exists(container: AssertionContainer<T>, linkOption: LinkOption?): Assertion
fun <T : Path> existsNot(container: AssertionContainer<T>, linkOption: LinkOption?): Assertion
fun <T : Path> extension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> fileName(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> fileNameWithoutExtension(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, String>
fun <T : Path> hasDirectoryEntry(container: AssertionContainer<T>, entries: List<String>): Assertion
fun <T : Path> hasSameBinaryContentAs(container: AssertionContainer<T>, targetPath: Path): Assertion
fun <T : Path> hasSameTextualContentAs(container: AssertionContainer<T>, targetPath: Path, sourceCharset: Charset, targetCharset: Charset): Assertion
fun <T : Path> isAbsolute(container: AssertionContainer<T>): Assertion
fun <T : Path> isDirectory(container: AssertionContainer<T>): Assertion
fun <T : Path> isExecutable(container: AssertionContainer<T>): Assertion
fun <T : Path> isReadable(container: AssertionContainer<T>): Assertion
fun <T : Path> isRegularFile(container: AssertionContainer<T>): Assertion
fun <T : Path> isRelative(container: AssertionContainer<T>): Assertion
fun <T : Path> isWritable(container: AssertionContainer<T>): Assertion
fun <T : Path> parent(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, Path>
fun <T : Path> resolve(container: AssertionContainer<T>, other: String): FeatureExtractorBuilder.ExecutionStep<T, Path>
fun <T : Path> startsNotWith(container: AssertionContainer<T>, expected: Path): Assertion
fun <T : Path> startsWith(container: AssertionContainer<T>, expected: Path): Assertion

class DefaultThrowableAssertions : ThrowableAssertions

DefaultThrowableAssertions()
fun <TExpected : Throwable> causeIsA(container: AssertionContainer<out Throwable>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected>

class DefaultZonedDateTimeAssertions : ZonedDateTimeAssertions

DefaultZonedDateTimeAssertions()
fun day(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>
fun dayOfWeek(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, DayOfWeek>
fun month(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>
fun year(container: AssertionContainer<ZonedDateTime>): FeatureExtractorBuilder.ExecutionStep<ZonedDateTime, Int>

package ch.tutteli.atrium.logic.kotlin_1_3

interface ResultAssertions

abstract fun <TExpected : Throwable> isFailureOfType(container: AssertionContainer<out Result<*>>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected>
abstract fun <E, T : Result<E>> isSuccess(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, E>

package ch.tutteli.atrium.logic.kotlin_1_3.impl

class DefaultResultAssertions : ResultAssertions

DefaultResultAssertions()
fun <TExpected : Throwable> isFailureOfType(container: AssertionContainer<out Result<*>>, expectedType: KClass<TExpected>): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected>
fun <E, T : Result<E>> isSuccess(container: AssertionContainer<T>): FeatureExtractorBuilder.ExecutionStep<T, E>

package ch.tutteli.atrium.logic.utils

class ArgumentMapperBuilder<out T>

ArgumentMapperBuilder(first: T, others: Array<out T>)
val first: T
val others: Array<out T>
inline fun <reified R> to(mapper: (T) -> R): Pair<R, Array<out R>>
inline fun <reified R> toExpect(crossinline assertionCreator: Expect<R>.(T) -> Unit): Pair<Expect<R>.() -> Unit, Array<Expect<R>.() -> Unit>>

class ArgumentToNullOrMapperBuilder<T : Any>

ArgumentToNullOrMapperBuilder(argumentMapperBuilder: ArgumentMapperBuilder<T?>)
val argumentMapperBuilder: ArgumentMapperBuilder<T?>
inline fun <R : Any> toExpect(crossinline assertionCreator: Expect<R>.(T) -> Unit): Pair<(Expect<R>.() -> Unit)?, Array<(Expect<R>.() -> Unit)?>>

inline fun <T> expectLambda(noinline assertionCreator: Expect<T>.() -> Unit): Expect<T>.() -> Unit
fun <T> AssertionContainer<*>.iterableLikeToIterable(iterableLike: IterableLike): Iterable<T>
fun <T> AssertionContainer<*>.iterableLikeToIterableWithoutCheckForElements(iterableLike: IterableLike): Iterable<T>
fun <T> mapArguments(first: T, others: Array<out T>): ArgumentMapperBuilder<T>
inline fun <T, reified R> mapArguments(first: T, others: Array<out T>, mapper: (T) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Byte, others: ByteArray): ArgumentMapperBuilder<Byte>
inline fun <reified R> mapArguments(first: Byte, others: ByteArray, mapper: (Byte) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Char, others: CharArray): ArgumentMapperBuilder<Char>
inline fun <reified R> mapArguments(first: Char, others: CharArray, mapper: (Char) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Short, others: ShortArray): ArgumentMapperBuilder<Short>
inline fun <reified R> mapArguments(first: Short, others: ShortArray, mapper: (Short) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Int, others: IntArray): ArgumentMapperBuilder<Int>
inline fun <reified R> mapArguments(first: Int, others: IntArray, mapper: (Int) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Long, others: LongArray): ArgumentMapperBuilder<Long>
inline fun <reified R> mapArguments(first: Long, others: LongArray, mapper: (Long) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Float, others: FloatArray): ArgumentMapperBuilder<Float>
inline fun <reified R> mapArguments(first: Float, others: FloatArray, mapper: (Float) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Double, others: DoubleArray): ArgumentMapperBuilder<Double>
inline fun <reified R> mapArguments(first: Double, others: DoubleArray, mapper: (Double) -> R): Pair<R, Array<out R>>
fun mapArguments(first: Boolean, others: BooleanArray): ArgumentMapperBuilder<Boolean>
inline fun <reified R> mapArguments(first: Boolean, others: BooleanArray, mapper: (Boolean) -> R): Pair<R, Array<out R>>
fun <K, V> AssertionContainer<*>.mapLikeToIterablePair(mapLike: MapLike): List<Pair<K, V>>
fun <K, V> AssertionContainer<*>.mapLikeToVarArgPairs(mapLike: MapLike): Pair<Pair<K, V>, Array<out Pair<K, V>>>
inline fun <T> nullable(t: T): T?
inline fun <T> nullable(t: KFunction0<T>): KFunction0<T?>
@JvmName("nullable1") inline fun <T1, R> nullable(t: KFunction1<T1, R>): KFunction1<T1, R?>
@JvmName("nullable2") inline fun <T1, T2, R> nullable(t: KFunction2<T1, T2, R>): KFunction2<T1, T2, R?>
@JvmName("nullable3") inline fun <T1, T2, T3, R> nullable(t: KFunction3<T1, T2, T3, R>): KFunction3<T1, T2, T3, R?>
@JvmName("nullable4") inline fun <T1, T2, T3, T4, R> nullable(t: KFunction4<T1, T2, T3, T4, R>): KFunction4<T1, T2, T3, T4, R?>
@JvmName("nullable5") inline fun <T1, T2, T3, T4, T5, R> nullable(t: KFunction5<T1, T2, T3, T4, T5, R>): KFunction5<T1, T2, T3, T4, T5, R?>
inline fun <T> nullableContainer(iterable: Iterable<T>): Iterable<T?>
inline fun <T> nullableContainer(arr: Array<out T>): Array<out T?>
inline fun <K, V : Any> nullableKeyMap(map: Map<out K, V>): Map<out K?, V>
inline fun <K, V> nullableKeyValueMap(map: Map<out K, V>): Map<out K?, V?>
inline fun <K : Any, V> nullableValueMap(map: Map<K, V>): Map<K, V?>
fun <T : Any> ArgumentMapperBuilder<T?>.toNullOr(): ArgumentToNullOrMapperBuilder<T>
inline fun <reified T> CharSequenceContains.CheckerStepLogic<*, *>.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>
inline fun <reified T> CharSequenceContains.EntryPointStepLogic<*, *>.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>
inline fun <reified T> IterableLikeContains.CheckerStepLogic<*, *, *>.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>
inline fun <reified T> IterableLikeContains.EntryPointStepLogic<*, *, *>.toVarArg(iterableLike: IterableLike): Pair<T, Array<out T>>
fun <K, V> MapLikeContains.EntryPointStepLogic<*, *, *, *>.toVarArgPairs(mapLike: MapLike): Pair<Pair<K, V>, Array<out Pair<K, V>>>

package ch.tutteli.atrium.reporting

interface AssertionFormatter

val CALL_FORMAT_GROUP: String
abstract fun canFormat(assertion: Assertion): Boolean
open fun format(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
abstract fun formatGroup(assertionGroup: AssertionGroup, parameterObject: AssertionFormatterParameterObject, formatAssertions: (AssertionFormatterParameterObject, (Assertion) -> Unit) -> Unit): Unit
abstract fun formatNonGroup(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
fun throwNotIntendedForAssertionGroups(): Unit

interface AssertionFormatterController

abstract fun format(assertion: Assertion, parameterObject: AssertionFormatterParameterObject): Unit
open fun isExplanatoryAssertionGroup(assertion: Assertion): Boolean
fun noSuitableAssertionFormatterFound(assertion: Assertion): Nothing
abstract fun register(assertionFormatter: AssertionFormatter): Unit

interface AssertionFormatterFacade

abstract fun format(assertion: Assertion, sb: StringBuilder, assertionFilter: (Assertion) -> Boolean): Unit
abstract fun register(assertionFormatterFactory: (AssertionFormatterController) -> AssertionFormatter): Unit

class AssertionFormatterParameterObject

fun appendLnAndIndent(): Unit
fun appendLnIndentAndPrefix(): Unit
val assertionFilter: (Assertion) -> Boolean
fun createChildWithNewPrefix(newPrefix: String): AssertionFormatterParameterObject
fun createChildWithNewPrefixAndAdditionalIndent(newPrefix: String, additionalIndent: Int): AssertionFormatterParameterObject
fun createForDoNotFilterAssertionGroup(): AssertionFormatterParameterObject
fun createForExplanatoryFilterAssertionGroup(newPrefix: String = prefix): AssertionFormatterParameterObject
fun indent(numberOfSpaces: Int): Unit
fun isNotInDoNotFilterGroup(): Boolean
fun isNotInExplanatoryFilterGroup(): Boolean
fun new(sb: StringBuilder, assertionFilter: (Assertion) -> Boolean): AssertionFormatterParameterObject
val prefix: String
val sb: StringBuilder

interface AssertionPairFormatter

abstract fun format(parameterObject: AssertionFormatterParameterObject, translatable: Translatable, representation: Any): Unit
abstract fun formatGroupHeader(parameterObject: AssertionFormatterParameterObject, assertionGroup: AssertionGroup, newParameterObject: AssertionFormatterParameterObject): Unit

expect class AtriumError : AssertionError

fun create(message: String, atriumErrorAdjuster: AtriumErrorAdjuster): AtriumError
fun getLocalizedMessage(): String?
val message: String?
fun toString(): String

expect interface AtriumErrorAdjuster : AtriumErrorAdjusterCommon

abstract fun adjustStackTrace(stackTrace: Sequence<StackTraceElement>): Sequence<StackTraceElement>

interface AtriumErrorAdjusterCommon

abstract fun adjust(throwable: Throwable): Unit
abstract fun adjustOtherThanStacks(throwable: Throwable): Unit

const val BUG_REPORT_URL: String
class LazyRepresentation

LazyRepresentation(provider: () -> Any?)
fun eval(): Any?

interface MethodCallFormatter

abstract fun format(methodName: String, arguments: Array<out Any?>): () -> String
abstract fun formatArgument(argument: Any?): String
abstract fun formatCall(methodName: String, arguments: Array<out Any?>): String

interface ObjectFormatter

abstract fun format(value: Any?): String

interface RawString

fun create(string: String): RawString
fun create(translatable: Translatable): RawString
val EMPTY: StringBasedRawString
val NULL: StringBasedRawString

interface Reporter

abstract val atriumErrorAdjuster: AtriumErrorAdjuster
abstract fun format(assertion: Assertion, sb: StringBuilder): Unit

val reporter: Reporter
class ReporterBuilder

ReporterBuilder(assertionFormatterFacade: AssertionFormatterFacade)
class AssertionFormatterChosenOptions

AssertionFormatterChosenOptions(assertionFormatterFacade: AssertionFormatterFacade, objectFormatter: ObjectFormatter, translator: Translator)
val assertionFormatterFacade: AssertionFormatterFacade
val objectFormatter: ObjectFormatter
val translator: Translator

class AssertionFormatterControllerOptions

AssertionFormatterControllerOptions(objectFormatter: ObjectFormatter, translator: Translator)
fun withAssertionFormatterController(assertionFormatterController: AssertionFormatterController): ReporterBuilder.AssertionFormatterFacadeOptions
fun withDefaultAssertionFormatterController(): ReporterBuilder.AssertionFormatterFacadeOptions

class AssertionFormatterFacadeOptions

AssertionFormatterFacadeOptions(assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator)
fun withAssertionFormatterFacade(factory: (AssertionFormatterController) -> AssertionFormatterFacade): ReporterBuilder.AssertionPairFormatterOptions
fun withDefaultAssertionFormatterFacade(): ReporterBuilder.AssertionPairFormatterOptions

class AssertionPairFormatterOptions

AssertionPairFormatterOptions(options: ReporterBuilder.AssertionFormatterChosenOptions)
fun withSameLineTextAssertionFormatter(vararg bulletPoints: Pair<Class<out BulletPointIdentifier>, String>): ReporterBuilder
fun withTextAssertionPairFormatter(factory: (ObjectFormatter, Translator) -> AssertionPairFormatter): ReporterBuilder.TextAssertionFormatterOptions
fun withTextSameLineAssertionPairFormatter(): ReporterBuilder.TextAssertionFormatterOptions

fun buildCustomReporter(factory: (AssertionFormatterFacade) -> Reporter): Reporter
fun buildOnlyFailureReporter(): Reporter
class LocaleOrderDeciderOptions

LocaleOrderDeciderOptions(translationSupplier: TranslationSupplier)
fun withDefaultLocaleOrderDecider(): ReporterBuilder.TranslatorOptions
fun withLocaleOrderDecider(localeOrderDecider: LocaleOrderDecider): ReporterBuilder.TranslatorOptions

class ObjectFormatterOptions

ObjectFormatterOptions(translator: Translator)
fun withDetailedObjectFormatter(): ReporterBuilder.AssertionFormatterControllerOptions
fun withObjectFormatter(factory: (Translator) -> ObjectFormatter): ReporterBuilder.AssertionFormatterControllerOptions

class TextAssertionFormatterOptions

TextAssertionFormatterOptions(options: ReporterBuilder.AssertionFormatterChosenOptions, assertionPairFormatter: AssertionPairFormatter)
fun withDefaultTextCapabilities(vararg bulletPoints: Pair<Class<out BulletPointIdentifier>, String>): ReporterBuilder
fun withTextAssertionFormatter(factory: (ReporterBuilder.AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter, vararg otherFactories: (ReporterBuilder.AssertionFormatterChosenOptions) -> (AssertionFormatterController) -> AssertionFormatter): ReporterBuilder

class TranslatorOptions

TranslatorOptions(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider)
fun withDefaultTranslator(primaryLocale: Locale, vararg fallbackLocales: Locale): ReporterBuilder.ObjectFormatterOptions
fun withTranslator(factory: (TranslationSupplier, LocaleOrderDecider) -> Translator): ReporterBuilder.ObjectFormatterOptions

fun withDefaultTranslationSupplier(): ReporterBuilder.LocaleOrderDeciderOptions
fun withoutTranslations(primaryLocale: Locale = java.util.Locale.getDefault()): ReporterBuilder.ObjectFormatterOptions
fun withTranslationSupplier(translationSupplier: TranslationSupplier): ReporterBuilder.LocaleOrderDeciderOptions
fun withTranslator(translator: Translator): ReporterBuilder.ObjectFormatterOptions

interface ReporterFactory

const val ATRIUM_PROPERTY_KEY: String
abstract fun create(): Reporter
abstract val id: String
fun specifyFactory(reporterFactoryId: String): Unit
fun specifyFactoryIfNotYetSet(reporterFactoryId: String): Unit

const val SHOULD_NOT_BE_SHOWN_TO_THE_USER_BUG: String
val SHOULD_NOT_BE_SHOWN_TO_THE_USER_BUG_TRANSLATABLE: Untranslatable
data class StringBasedRawString : RawString

val string: String

data class Text

val EMPTY: Text
operator fun invoke(string: String): Text
val NULL: Text
val string: String

package ch.tutteli.atrium.reporting.translating

abstract class ArgumentsSupportingTranslator : Translator

ArgumentsSupportingTranslator(primaryLocale: Locale, fallbackLocales: List<Locale>)
protected val fallbackLocales: List<Locale>
protected val primaryLocale: Locale
fun translate(translatable: Translatable): String
protected abstract fun translateWithoutArgs(translatable: Translatable): String

expect fun getDefaultLocale(): Locale
data class Locale

Locale(language: String, country: String)
Locale(language: String)
Locale(language: String, script: String?, country: String?, variant: String?)
val country: String?
val language: String
val script: String?
fun toString(): String
val variant: String?

interface LocaleOrderDecider

abstract fun determineOrder(primaryLocale: Locale, fallbackLocales: List<Locale>): Sequence<Locale>

interface StringBasedTranslatable : Translatable

open fun getDefault(): String
abstract val value: String

fun Locale.toJavaLocale(): Locale
interface Translatable

abstract fun getDefault(): String
open val id: String
const val ID_SEPARATOR: String
abstract val name: String

data class TranslatableBasedRawString : RawString

val translatable: Translatable

data class TranslatableWithArgs : Translatable

TranslatableWithArgs(translatable: Translatable, argument: Any)
TranslatableWithArgs(translatable: Translatable, arg1: Any, arg2: Any)
TranslatableWithArgs(translatable: Translatable, arg1: Any, arg2: Any, vararg otherArgs: Any)
TranslatableWithArgs(translatable: Translatable, arguments: List<Any>)
val arguments: List<Any>
fun getDefault(): String
val name: String
val translatable: Translatable

interface TranslationSupplier

abstract fun get(translatable: Translatable, locale: Locale): String?

interface Translator

abstract fun translate(translatable: Translatable): String

class Untranslatable : Translatable

Untranslatable(representation: CharSequence)
Untranslatable(representation: () -> String)
Untranslatable(representation: String)
val EMPTY: Untranslatable
fun getDefault(): String
val name: String
fun toString(): String

class UsingDefaultTranslator : ArgumentsSupportingTranslator

UsingDefaultTranslator(primaryLocale: Locale = getDefaultLocale())
protected fun translateWithoutArgs(translatable: Translatable): String

package ch.tutteli.atrium.translations

enum class DescriptionAnyAssertion : StringBasedTranslatable

BECAUSE
IS_A
IS_NONE_OF
IS_NOT_SAME
IS_SAME
NOT_TO_BE
TO_BE
val value: String

enum class DescriptionBasic : StringBasedTranslatable

HAS
HAS_NOT
IS
IS_NOT
NONE
NOT_TO
NOT_TO_BE
TO
TO_BE
val value: String
WAS

enum class DescriptionBigDecimalAssertion : StringBasedTranslatable

FAILURE_IS_EQUAL_INCLUDING_SCALE_BUT_NUMERICALLY_EQUAL
IS_EQUAL_INCLUDING_SCALE
IS_NOT_EQUAL_INCLUDING_SCALE
IS_NOT_NUMERICALLY_EQUAL_TO
IS_NUMERICALLY_EQUAL_TO
val value: String

enum class DescriptionCharSequenceAssertion : StringBasedTranslatable

AT_LEAST
AT_MOST
BLANK
CONTAINS
CONTAINS_NOT
EMPTY
ENDS_NOT_WITH
ENDS_WITH
EXACTLY
IGNORING_CASE
MATCHES
MISMATCHES
NUMBER_OF_OCCURRENCES
STARTS_NOT_WITH
STARTS_WITH
STRING_MATCHING_REGEX
VALUE
val value: String

enum class DescriptionCollectionAssertion : StringBasedTranslatable

EMPTY
SIZE
val value: String

enum class DescriptionComparableAssertion : StringBasedTranslatable

IS_EQUAL
IS_GREATER_OR_EQUALS
IS_GREATER_THAN
IS_GREATER_THAN_OR_EQUAL
IS_LESS_OR_EQUALS
IS_LESS_THAN
IS_LESS_THAN_OR_EQUAL
val value: String

enum class DescriptionDateTimeLikeAssertion : StringBasedTranslatable

DAY
DAY_OF_WEEK
IS_AFTER
IS_AFTER_OR_EQUAL
IS_BEFORE
IS_BEFORE_OR_EQUAL
IS_EQUAL_TO
MONTH
SAME_DAY
val value: String
YEAR

enum class DescriptionFloatingPointAssertion : StringBasedTranslatable

FAILURE_DUE_TO_FLOATING_POINT_NUMBER
TO_BE_WITH_ERROR_TOLERANCE
TO_BE_WITH_ERROR_TOLERANCE_EXPLAINED
val value: String

enum class DescriptionFunLikeAssertion : StringBasedTranslatable

IS_NOT_THROWING_1
IS_NOT_THROWING_2
NO_EXCEPTION_OCCURRED
THREW
THROWN_EXCEPTION_WHEN_CALLED
val value: String

enum class DescriptionIterableAssertion : StringBasedTranslatable

ALL
AN_ELEMENT_WHICH
AN_ELEMENT_WHICH_EQUALS
AN_ENTRY_WHICH
AN_ENTRY_WHICH_IS
AT_LEAST
AT_MOST
CANNOT_EVALUATE_SUBJECT_EMPTY_ITERABLE
CANNOT_EVALUATE_SUBJECT_ONLY_NULL
CONTAINS
CONTAINS_NOT
DUPLICATE_ELEMENTS
ELEMENT_WITH_INDEX
ENTRY_WITH_INDEX
EXACTLY
HAS_ELEMENT
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
IN_ORDER_ONLY_GROUPED
INDEX
INDEX_FROM_TO
NEXT_ELEMENT
NO_ELEMENTS
NUMBER_OF_OCCURRENCES
SIZE_EXCEEDED
val value: String
WARNING_ADDITIONAL_ELEMENTS
WARNING_ADDITIONAL_ENTRIES
WARNING_MISMATCHES
WARNING_MISMATCHES_ADDITIONAL_ELEMENTS
WARNING_MISMATCHES_ADDITIONAL_ENTRIES

enum class DescriptionListAssertion : StringBasedTranslatable

CANNOT_EVALUATE_INDEX_OUT_OF_BOUNDS
INDEX_OUT_OF_BOUNDS
val value: String

enum class DescriptionMapAssertion : StringBasedTranslatable

CANNOT_EVALUATE_KEY_DOES_NOT_EXIST
CONTAINS_IN_ANY_ORDER
CONTAINS_KEY
CONTAINS_NOT_KEY
ENTRY_WITH_KEY
KEY_DOES_NOT_EXIST
SIZE
val value: String

enum class DescriptionMapLikeAssertion : StringBasedTranslatable

CONTAINS
CONTAINS_KEY
CONTAINS_NOT_KEY
ENTRY_WITH_KEY
IN_ANY_ORDER
IN_ANY_ORDER_ONLY
IN_ORDER
IN_ORDER_ONLY
KEY_DOES_NOT_EXIST
val value: String
WARNING_ADDITIONAL_ENTRIES

enum class DescriptionOptionalAssertion : StringBasedTranslatable

EMPTY
GET
IS_NOT_PRESENT
val value: String

enum class DescriptionPathAssertion : StringBasedTranslatable

A_DIRECTORY
A_FILE
A_SYMBOLIC_LINK
A_UNKNOWN_FILE_TYPE
ABSOLUTE_PATH
DOES_NOT_HAVE_PARENT
ENDS_NOT_WITH
ENDS_WITH
EXECUTABLE
EXIST
EXTENSION
FAILURE_DUE_TO_ACCESS_DENIED
FAILURE_DUE_TO_ACCESS_EXCEPTION
FAILURE_DUE_TO_LINK_LOOP
FAILURE_DUE_TO_NO_SUCH_FILE
FAILURE_DUE_TO_PARENT
FAILURE_DUE_TO_PERMISSION_FILE_TYPE_HINT
FAILURE_DUE_TO_WRONG_FILE_TYPE
FILE_NAME
FILE_NAME_WITHOUT_EXTENSION
HAS_SAME_BINARY_CONTENT
HAS_SAME_TEXTUAL_CONTENT
HINT_ACTUAL_ACL_PERMISSIONS
HINT_ACTUAL_POSIX_PERMISSIONS
HINT_CLOSEST_EXISTING_PARENT_DIRECTORY
HINT_FOLLOWED_SYMBOLIC_LINK
HINT_OWNER
HINT_OWNER_AND_GROUP
PARENT
READABLE
RELATIVE_PATH
STARTS_NOT_WITH
STARTS_WITH
val value: String
WRITABLE

enum class DescriptionResultAssertion : StringBasedTranslatable

EXCEPTION
IS_NOT_FAILURE
IS_NOT_SUCCESS
VALUE
val value: String

enum class DescriptionThrowableAssertion : StringBasedTranslatable

IS_A
IS_NOT_THROWN_1
IS_NOT_THROWN_2
NO_EXCEPTION_OCCURRED
NOT_CAUSED
OCCURRED_EXCEPTION_CAUSE
OCCURRED_EXCEPTION_MESSAGE
OCCURRED_EXCEPTION_PROPERTIES
OCCURRED_EXCEPTION_STACKTRACE
OCCURRED_EXCEPTION_SUPPRESSED
val value: String

enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable

IS_A
val value: String
WARNING_DOWN_CAST_FAILED

enum class ErrorMessages : StringBasedTranslatable

AT_LEAST_ONE_ASSERTION_DEFINED
DEDSCRIPTION_BASED_ON_SUBJECT
DESCRIPTION_BASED_ON_SUBJECT
FORGOT_DO_DEFINE_ASSERTION
HINT_AT_LEAST_ONE_ASSERTION_DEFINED
REPRESENTATION_BASED_ON_SUBJECT_NOT_DEFINED
SUBJECT_ACCESSED_TOO_EARLY
val value: String

package ch.tutteli.atrium.verbs

fun <T : Any> assert(subject: T): ReportingAssertionPlant<T>
fun <T : Any> assert(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun assert(act: () -> Unit): ThrowableThrown.Builder
fun <T : Any, R : Any> Assert<T>.assert(newSubject: R): Assert<R>
enum class AssertionVerb : StringBasedTranslatable

ASSERT
ASSERT_THAT
ASSERT_THAT_THROWN
ASSERT_THROWN
EXPECT
EXPECT_THROWN
val value: String

fun <T : Any> assertThat(subject: T): ReportingAssertionPlant<T>
fun <T : Any> assertThat(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun assertThat(act: () -> Unit): ThrowableThrown.Builder
fun <T : Any, R : Any> Assert<T>.assertThat(newSubject: R): Assert<R>
fun <T : Any> expect(subject: T): ReportingAssertionPlant<T>
fun <T : Any> expect(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun expect(act: () -> Unit): ThrowableThrown.Builder
fun <T : Any, R : Any> Assert<T>.expect(newSubject: R): Assert<R>

package ch.tutteli.atrium.verbs.assert

fun <T : Any> assert(subject: T): ReportingAssertionPlant<T>
fun <T : Any> assert(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun assert(act: () -> Unit): ThrowableThrown.Builder

package ch.tutteli.atrium.verbs.assertthat

fun <T : Any> assertThat(subject: T): ReportingAssertionPlant<T>
fun <T : Any> assertThat(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun assertThat(act: () -> Unit): ThrowableThrown.Builder

package ch.tutteli.atrium.verbs.expect

fun <T : Any> expect(subject: T): ReportingAssertionPlant<T>
fun <T : Any> expect(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun expect(act: () -> Unit): ThrowableThrown.Builder

package ch.tutteli.atrium.verbs.internal

fun <T : Any> assert(subject: T): ReportingAssertionPlant<T>
fun <T : Any> assert(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
enum class AssertionVerb : StringBasedTranslatable

ASSERT
EXPECT_THROWN
val value: String

object AssertionVerbFactory : AssertionVerbFactory

fun checkException(act: () -> Unit): ThrowableThrown.Builder
fun <T : Any> checkImmediately(subject: T): ReportingAssertionPlant<T>
fun <T : Any> checkLazily(subject: T, assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T> checkNullable(subject: T): ReportingAssertionPlantNullable<T>

fun expect(act: () -> Unit): ThrowableThrown.Builder
class NoAdjustingReporterFactory : ReporterFactory

NoAdjustingReporterFactory()
fun create(): Reporter
val id: String
const val ID: String